Python Request.prepare方法代码示例

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [as 别名]
    def get_http_request(url, payload, method='POST', headers=None, use_proxy=False, use_proxy_auth=False, trust_env=True):
        try:
            session = Session()
            session.trust_env = trust_env
            session.proxies = Util.get_proxies() if use_proxy else None
            session.auth = Util.get_proxy_auth() if use_proxy_auth else None

            request = Request(
                'POST' if method not in ('GET', 'POST') else method,
                url,
                data=payload if method == 'POST' else None,
                params=payload if method == 'GET' else None,
                headers=headers
            )

            prepped = request.prepare()

            response = session.send(
                prepped,
                timeout=app.config['HTTP_REQUESTS_TIMEOUT']
            )

            session.close()
        except Exception, e:
            response = Response()
            response.raise_for_status()
            return response, 'Error al realizar la consulta - Motivo: {}'.format(e.message)

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [as 别名]
def prepare_and_send_request(request_method, request_url, payload=None, authorization=None):

	headers = {
		'Accept' : 'application/json',
		'Accept-Encoding' : 'gzip,deflate,sdch',
		'Accept-Language' : 'en-US,en;q=0.8,pt-BR;q=0.6,pt;q=0.4',
		'Cache-Control' : 'no-cache',
		'Connection' : 'keep-alive',
	}

	if ( authorization != None ):
		headers['Authorization'] = "Basic " + base64.b64encode("%s:%s" % (authorization, TEST_USER_PASSWORD))

	if ( payload == None ):
		req = Request(request_method, request_url, headers=headers)
		r = req.prepare()
	else:
		headers['Content-Type'] = 'application/json'		
		req = Request(request_method, request_url, data=json.dumps(payload), headers=headers)
		r = req.prepare()

	s = Session()
	s.mount('https://', SSLAdapter('TLSv1'))

	try:
		resp = s.send(r, verify=False, timeout=1)
	except Timeout, SSLError:
		return prepare_and_send_request(request_method, request_url, payload, authorization)

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [as 别名]
def main(args):
    if len(args) != 1:
       print "Usage monitor.py [number of entries to retrieve]"
       sys.exit(1)
    elif args[0].isdigit() == False:
       print "Usage monitor.py [number of entries to retrieve]"
       sys.exit(1)
    offset = int(args[0])
    operation = 'ct/v1/get-sth'
    url = 'http://ct.googleapis.com/aviator/{}'.format(operation)
    
    s = Session()
    r = Request('GET', url)
    
    prepped = r.prepare()
    
    r = s.send(prepped)
    
    numcerts = 0
    
    if r.status_code == 200:
        sth = r.json()
        numcerts = sth['tree_size']
    
    operation = 'ct/v1/get-entries'
    url = 'http://ct.googleapis.com/aviator/{}'.format(operation)
    
    endindex = numcerts - 1
    startindex = numcerts - offset
    
    params = urllib.urlencode({'start':startindex,'end':endindex})
    
    
    s = Session()
    
    r = Request('GET',
                 '{}?{}'.format(url,params),
                 )
    
    prepped = r.prepare()
    
    r = s.send(prepped)
    
    if r.status_code == 200:
        entries = r.json()['entries']
        for i in entries:
            print "End entity cert"
            parse_leafinput(base64.b64decode(i['leaf_input']))
            print "Signing cert chain"
            parse_asn1certs(base64.b64decode(i['extra_data']))
    else:
        print r.status_code
        print r.text

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [as 别名]
 def recuperar_acuse(self, uuid):
     transaccion_id = get_epoch()
     user_token = self._get_token(transaccion_id)
     if not user_token:
         return ''
     method = 'recuperar_acuse'
     data = {
         'uuid': uuid,
         'rfc': self.rfc,
         'user_token': user_token,
         'transaccion_id': transaccion_id,
     }
     data = self._SOAP[method].format(**data).encode('utf-8')
     headers = {
         'SOAPAction': '"{}"'.format(self._ACTIONS[method]),
         'Content-length': len(data),
         'Content-type': 'text/xml; charset="UTF-8"'
     }
     s = Session()
     req = Request('POST', self.WS['cancelacion'], data=data, headers=headers)
     prepped = req.prepare()
     try:
         response = s.send(prepped, timeout=TIMEOUT)
         res = xml2dict.parse(response.text)
         ok, res = self._check_fault(res)
         if ok:
             return ''
         return res['RespuestaRecuperarAcuse']['AcuseXML'].replace("'", '"')
     except exceptions.Timeout:
         self.error = 'Tiempo de espera agotado'
         print (self.error)
     except Exception as e:
         print ('Recuperar Acuse', e)
     return

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [as 别名]
    def doRequest(self, method, url, params=None, parse=True, data=None):
        """ Send HTTP request, with given method,
            credentials and data to the given URL,
            and return the success and the result on success.
        """
        if not self.bitbucket.auth:
            raise ValueError("No auth credentials.")

        if data:
            data = dict(data)
        else:
            data = {}
        
        r = Request(
            method=method,
            url=url,
            auth=self.bitbucket.auth,
            params=params,
            data=data
        )
        s = Session()
        resp = s.send(r.prepare())
        status = resp.status_code
        text = resp.text
        error = resp.reason
        if status >= 200 and status < 300:
            if parse:
                return json.loads(text)
            else:
                return text
        else:
            raise exceptions.DispatchError(text, url, error, status)

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [as 别名]
    def test_contents_copy_no_content(self):

        self.session.put(self.addr_m2_ref)
        req = Request('COPY', self.addr_m2_ref_path,
                      headers={'Destination': self.path_paste_wrong})
        resp = self.session.send(req.prepare())
        self.assertTrue(resp.status_code, 400)

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [as 别名]
    def login(self, username, password):
        url = 'http://www.renren.com/PLogin.do'

        data = {
            'email':username,
            'password':password,
            'icode':'',
            'origURL':'ttp://www.renren.com/home',
            'domain':'renren.com',
            'key_id':1,
            'captcha_type':'web_login',
        }
        req = Request('POST', url,
            data=data,
            headers=self.headers
        )
        prepped = req.prepare()

        # do something with prepped.body
        # do something with prepped.headers
        resp = self.send(prepped,
            # stream=stream,
            # verify=verify,
            # proxies=proxies,
            # cert=cert,
            # timeout=timeout
        )
        self._html =  resp.text
        self._extract_params()
        # login success:
        # ver=7.0; domain=.renren.com; path=/, loginfrom=null; domain=.renren.com; path=/, JSESSIONID=abcnxywIfD6yF6Gelpsov; path=/
        print 'login succeeded!' if u'王那' in resp.text  else 'login failed'

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [as 别名]
def generate_prepared_request(method, url, headers, data, params, handlers):
    """Add handlers and prepare a Request.

    Parameters
        method (str)
            HTTP Method. (e.g. 'POST')
        headers (dict)
            Headers to send.
        data (JSON-formatted str)
            Body to attach to the request.
        params (dict)
            Dictionary of URL parameters to append to the URL.
        handlers (list)
            List of callback hooks, for error handling.

    Returns
        (requests.PreparedRequest)
            The fully mutable PreparedRequest object,
            containing the exact bytes to send to the server.
    """
    request = Request(
        method=method,
        url=url,
        headers=headers,
        data=data,
        params=params,
    )

    handlers.append(error_handler)

    for handler in handlers:
        request.register_hook('response', handler)

    return request.prepare()

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [as 别名]
    def _upload_file(self, params, prepped, api_session):
        # header for upload
        s3_session = Session()
        api_url = self._endpoint_url + "getS3url"
        req = Request('POST', api_url)
        upload_prepped = req.prepare()
        self._encode_headers(upload_prepped.headers)
        upload_prepped.headers['Content-Type'] = 'application/json'
        upload_prepped.headers['User-Agent'] = self._build_user_agent_header()
        self._signer.sign(upload_prepped)
        # prepare params for s3 url
        url_parameters = {'fileName': '', 'tenant': ''}
        if 'fileName' in params and params['fileName']:
            url_parameters['fileName'] = params['file_name']
        elif 'fileLocation' in params and params['fileLocation']:
            if os.path.isfile(params['fileLocation']):
                fileName = os.path.basename(params['fileLocation'])
                url_parameters['fileName'] = fileName

        if 'tenant' in params and params['tenant']:
            url_parameters['tenant'] = params['tenant']
        # prepare the body
        serializer = Serializer()
        serial_obj = serializer.serialize_to_request(url_parameters, None)
        upload_prepped.prepare_body(serial_obj['body'], None)
        resp = s3_session.send(upload_prepped)
        resp = json.loads(json.dumps(resp.json()))

        # upload file to S3 bucket
        if 'url' in resp and 'fileLocation' in params and params['fileLocation']:
            put(resp['url'], data=open(params['fileLocation']).read())
            # build upload parameters
            upload_params = {'rowDelim': '', 'colDelim': '', 'headerFields': [],
                             'tenant': '', 'fileType': 0}
            # now do actual upload
            if 'tenant' in params and params['tenant']:
                upload_params['tenant'] = params['tenant']
            upload_params['fileLocation'] = params['fileLocation']
            if os.path.isfile(params['fileLocation']):
                fileName = os.path.basename(params['fileLocation'])
                upload_params['fileName'] = fileName
            if 'fileName' in params and params['fileName']:
                upload_params['fileName'] = params['fileName']
            if 'sourcePlatform' in params and params['sourcePlatform']:
                upload_params['sourcePlatform'] = params['sourcePlatform']
            if 'colDelim' in params and params['colDelim']:
                upload_params['colDelim'] = params['colDelim']
            if 'rowDelim' in params and params['rowDelim']:
                upload_params['rowDelim'] = params['rowDelim']
            if 'headerFields' in params and params['headerFields']:
                upload_params['headerFields'] = params['headerFields']
            if 'fileType' in params and params['fileType']:
                upload_params['fileType'] = params['fileType']
            # prepare the body
            serializer = Serializer()
            serial_obj = serializer.serialize_to_request(upload_params, None)
            prepped.prepare_body(serial_obj['body'], None)
            resp = api_session.send(prepped)
            resp = json.dumps(resp.json())
        return resp

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [as 别名]
    def build_request(self, verb, data, verb_attrs, files=None):
 
        self.verb = verb
        self._request_dict = data
        self._request_id = uuid.uuid4()

        url = self.build_request_url(verb)

        headers = self.build_request_headers(verb)
        headers.update({'User-Agent': UserAgent, 
                        'X-EBAY-SDK-REQUEST-ID': str(self._request_id)})
                        
        # if we are adding files, we ensure there is no Content-Type header already defined
        # otherwise Request will use the existing one which is likely not to be multipart/form-data
        # data must also be a dict so we make it so if needed

        requestData = self.build_request_data(verb, data, verb_attrs)
        if files:
            del(headers['Content-Type'])
            if isinstance(requestData, basestring):
                requestData = {'XMLPayload':requestData}

        request = Request(self.method,
            url,
            data=requestData,
            headers=headers,
            files=files,
        )


        self.request = request.prepare()

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [as 别名]
    def authorize_url(self, duration, scopes, state, implicit=False):
        """Return the URL used out-of-band to grant access to your application.

        :param duration: Either ``permanent`` or ``temporary``. ``temporary``
            authorizations generate access tokens that last only 1
            hour. ``permanent`` authorizations additionally generate a refresh
            token that can be indefinitely used to generate new hour-long
            access tokens. Only ``temporary`` can be specified if ``implicit``
            is set to ``True``.
        :param scopes: A list of OAuth scopes to request authorization for.
        :param state: A string that will be reflected in the callback to
            ``redirect_uri``. This value should be temporarily unique to the
            client for whom the URL was generated for.
        :param implicit: (optional) Use the implicit grant flow (default:
            False). This flow is only available for UntrustedAuthenticators.

        """
        if self.redirect_uri is None:
            raise InvalidInvocation('redirect URI not provided')
        if implicit and not isinstance(self, UntrustedAuthenticator):
            raise InvalidInvocation('Only UntrustedAuthentictor instances can '
                                    'use the implicit grant flow.')
        if implicit and duration != 'temporary':
            raise InvalidInvocation('The implicit grant flow only supports '
                                    'temporary access tokens.')

        params = {'client_id': self.client_id, 'duration': duration,
                  'redirect_uri': self.redirect_uri,
                  'response_type': 'token' if implicit else 'code',
                  'scope': ' '.join(scopes), 'state': state}
        url = self._requestor.reddit_url + const.AUTHORIZATION_PATH
        request = Request('GET', url, params=params)
        return request.prepare().url

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [as 别名]
def build_environ(method, path, host='localhost',
                  accept_type='text/html', content_type=None,
                  query=None, form=None, files=None, cookies=None):
    if '://' in host:
        url = host.rstrip('/') + '/' + path.lstrip('/')
    else:
        url = 'http://' + host.strip('/') + '/' + path.lstrip('/')

    request = Request(method, url, None, files, form, query, cookies)
    prepared = request.prepare()
    parsed_url = parse_url(prepared.url)

    environ = {
        'HTTP_HOST': parsed_url.host,
        'PATH_INFO': parsed_url.path,
        'REQUEST_METHOD': prepared.method,

        'HTTP_ACCEPT': accept_type,

        'QUERY_STRING': parsed_url.query or '',
    }

    for key, value in iteritems(prepared.headers):
        key = underscore(key)
        if key not in ['content_type', 'content_length']:
            key = 'http_' + key
        environ[key.upper()] = value

    if content_type is not None:
        environ['CONTENT_TYPE'] = content_type

    environ['wsgi.input'] = BytesIO(prepared.body)

    return environ

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [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 prepare [as 别名]
    def _make_request(self, method, url, data=None, params=None, **kwargs):
        if params:
            self.params.update(params)
        if kwargs.get('headers'):
            self.headers.update(kwargs['headers'])
        if data:
            data = self._stringify_dict_list(data)

        url = self.BASE_URL + self.VERSION + url
        req = Request(method, url, data=data, headers=self.headers, params=self.params)
        prepped = req.prepare()

        try:
            response = self._session.send(prepped, timeout=self.timeout)
            if response.status_code > 299:
                if 'message' in str(response.content):
                    response.reason += ': {}'.format(response.json()['message'])
                response.raise_for_status()
        except requests.HTTPError:
            msg = '{} {}'.format(response.status_code, response.reason)
            raise HttpError(msg)
        except requests.Timeout:
            raise TimeoutError('{} {} timed out after {} seconds'.format(
                method, url, self.timeout[0] + self.timeout[1]
            ))
        except requests.ConnectionError as e:
            raise ClientError('Could not reach: {} {} {}'.format(method, url, e))

        return response.json()

# 需要导入模块: from requests import Request [as 别名]
# 或者: from requests.Request import prepare [as 别名]
 def get_estatus(self, data):
     data['emisor_rfc'] = escape(data['emisor_rfc'])
     data['receptor_rfc'] = escape(data['receptor_rfc'])
     data = self._soap.format(**data).encode('utf-8')
     headers = {
         'SOAPAction': '"http://tempuri.org/IConsultaCFDIService/Consulta"',
         'Content-length': len(data),
         'Content-type': 'text/xml; charset="UTF-8"'
     }
     s = Session()
     s.verify = False
     req = Request('POST', self._webservice, data=data, headers=headers)
     prepped = req.prepare()
     try:
         response = s.send(prepped, timeout=5)
         res = xml2dict.parse(response.text)
         ok, res = self._check_fault(res)
         if ok:
             return False
         self.msg = res['ConsultaResponse']['ConsultaResult']['a:Estado']
         return True
     except exceptions.Timeout:
         self.error = 'Tiempo de espera agotado'
     except Exception as e:
         print (e)
     return False