Python Session.send方法代码示例

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import send [as 别名]
def main2():
    # http://stackoverflow.com/questions/10247054/http-post-and-get-with-cookies-for-authentication-in-python

    s1 = Session()

    prepped = Request(
        "GET",  # or any other method, 'POST', 'PUT', etc.
        auth_url3,
        # data=data,
        # headers=headers
        # ...
    ).prepare()

    resp = s1.send(prepped)

    print "----------------"
    print "Cookie Details  ==  " + resp.request.headers["Cookie"]
    print "----------------"

    # Not Working
    headers = {"Cookie": resp.request.headers["Cookie"] + " ; company_guid=6f65b34d-b6f4-4abd-b14a-408b8a11029b"}

    # working : if this cookie expires then get the new one from browser
    #    headers = {
    #               "Cookie" : "AuthSession=aba1d850-5814-48f5-896f-2989609f02c5" + "; company_guid=6f65b34d-b6f4-4abd-b14a-408b8a11029b"
    #              }

    # working
    #    headers = {
    #               "Cookie" : "AuthSession=aba1d850-5814-48f5-896f-2989609f02c5; company_guid=6f65b34d-b6f4-4abd-b14a-408b8a11029b"
    #              }

    print "----------------"
    print headers
    print "----------------"

    prepped = Request(
        "GET",  # or any other method, 'POST', 'PUT', etc.
        response_url,
        # data=data,
        headers=headers
        # ...
    ).prepare()

    resp = s1.send(prepped)

    #    print(resp.status_code)
    #    print resp.text
    WriteToFile(
        "/home/rtandon/Downloads/Work/0037_TP5952_TCCC Response Time/Requirements/Response_Time_Json_Sample3.txt",
        resp.text,
    )
    print "done"

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import send [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 Session [as 别名]
# 或者: from requests.Session import send [as 别名]
class ApiRequest(object):
    """API request class, this will create prepared reqeusts and have
    basic auth data prepared on the request.
    """
    protocol = 'https'

    def __init__(self, api_key, subdomain):
        self.session = Session()
        self.subdomain = subdomain
        self.api_key = api_key

    def _prepare_request(self, api_url, method='GET', data=None):
        url = api_url.format(protocol=self.protocol, subdomain=self.subdomain)
        request = Request(
            url=url, method=method,
            headers={'authorization': 'Bearer {}'.format(self.api_key),
                     'Content-type': 'application/json'},
            data=json.dumps(data))
        return self.session.prepare_request(request)

    def post(self, api_url, data, headers={}):
        prepared_request = self._prepare_request(
            api_url=api_url, method="POST", data=data)
        return self.session.send(prepared_request)

    def get(self, api_url):
        prepared_request = self._prepare_request(api_url=api_url)
        return self.session.send(prepared_request)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import send [as 别名]
    def __request(self, path, method="GET", query=None, body=None,
                  headers=None):
        """
        Place a request on the remote API and return the result.

        :param path:
        :param method:
        :param query:
        :param body:
        :param headers:
        :return:
        """
        if headers is None:
            headers = {}
        if method.upper() in {"PUT", "POST"}:
            headers["Role"] = ",".join(self.role)
        headers["Date"] = http_date()
        if self.signer:
            headers["Authorization"] = self.__authorize(headers)
        session = Session()
        url = self.url + expand_user(path, self.user)
        request = Request(method, url, headers=headers, params=query, data=body)
        request = request.prepare()
        log.debug(format_prepared_request(request))
        if self.disable_ssl_certificate_validation is True:
            return session.send(request, verify=False)
        else:
            return session.send(request, verify=True)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import send [as 别名]
    def scrape(self):
        s = Session()
        self.table_headers = []

        # first request
        request_headers = {}
        for k, v in StLouis.DEFAULT_PAYLOAD.iteritems():
            request_headers[k] = v

        self.logger.info('Beginning scrape of stlouisfed.org')
        req = requests.Request('POST', StLouis.URL, headers=request_headers)
        prepped = s.prepare_request(req)
        req_payload = self._parse_table(self.table_headers, self.documents, s.send(prepped))
        self.logger.info('Initial request parsed %d rows' % len(self.documents))
        page_requests = 1


        # The "next" available pages are parsed and returned for each response
        # Keep requesting new pages while some "next" page is parsed from the response
        while (req_payload):
            req = requests.Request('POST', StLouis.URL, data=req_payload, headers=request_headers)
            prepped = s.prepare_request(req)
            req_payload = self._parse_table(self.table_headers, self.documents, s.send(prepped))
            page_requests += 1
        self.logger.info('Completed %d total page requests. Parsed %d total rows' % 
            (page_requests, len(self.documents)))

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import send [as 别名]
def main():
    session = Session()
    marketReq = showOrderbookCompactRequest()
    ratesReq = showRatesRequest()

    market = Market(session.send(marketReq).json())
    rates = session.send(ratesReq).json()
    course = Course(rates)
    print "---------------------------------------------"
    print "\t[*] Asks [*]"
    print "\tvolume: %f" % market.get_BidVolume()
    print "\tmedian price: %f" % market.get_BidMedian()
    print "\tavg price: %f" % market.get_BidAverage()
    print "\tcheapest: %f" % market.get_BidLowest()
    print "\tmost expensive: %f" % market.get_BidHighest()
    print "---------------------------------------------"
    print "\t[*] Bid [*]"
    print "\tvolume: %f" % market.get_AskVolume()
    print "\tmedian price: %f" % market.get_AskMedian()
    print "\tavg price: %f" % market.get_AskAverage()
    print "\thighest bid: %f" % market.get_AskHighest()
    print "\tlowest bid: %f" % market.get_AskLowest()
    print "---------------------------------------------"
    print "\t[*] courses [*]"
    print "\texact: %f" % course.getCurrentRate()
    print "\t12 Hours: %f" % course.get12hWeighted()
    print "\t3 hours: %f" % course.get3hWeighted()

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import send [as 别名]
    def send_stuck_machine_support_request(
            self, machine_id, machine_address, contact_mail_address):
        if self.dry_run:
            return
        session = Session()
        req = Request('GET', SUPPORT_HOST + 'anonymous_requests/new')
        resp = session.send(session.prepare_request(req))
        if resp.status_code != 200:
            raise SupportRequestError(
                'Got {} HTTP status reading the support form page'.format(
                    resp.status_code))
        parser = FormParser()
        parser.feed(resp.text)
        found_fields = set(parser.hidden_fields)
        found_fields.update(set(parser.visible_fields))
        if found_fields != EXPECTED_FIELDS:
            print(
                "Warning: Found field names differ from expected field names.")
            print("  not expected: {}".format(
                found_fields.difference(EXPECTED_FIELDS)))
            print("  missing: {}".format(
                EXPECTED_FIELDS.difference(found_fields)))
        if 'sev-2' not in parser.importance_field_values:
            print("Warning: Expected severity 'sev-2' not found in form data.")

        form_data = parser.hidden_fields
        form_data[EMAIL_FIELD_NAME] = contact_mail_address
        form_data[SUBJECT_FIELD_NAME] = 'Machine stuck in provisioning state'
        form_data[DESCRIPTION_FIELD_NAME] = dedent("""\
            Please delete the machine {} which is stuck in provisioning.

            Thank you
        """).format(machine_id)
        form_data[SEVERITY_FIELD_NAME] = 'sev-2'
        form_data[IP_ADDRESS_FIELD_NAME] = machine_address
        # A text field that is visibly hidden.
        form_data[COMMENT_BODY_FIELD_NAME] = ''

        req = Request(
            'POST', SUPPORT_HOST + parser.post_url, data=form_data)
        resp = session.send(session.prepare_request(req))
        if resp.status_code != 200:
            raise SupportRequestError(
                'Server response to support form POST: {}'.format(
                    resp.status_code))
        with open('joyent-form-response.html', 'w') as f:
            f.write(resp.text.encode('utf-8'))
        mo = re.search('<div id="error">(.*?)</div>', resp.text)
        if mo is not None:
            raise SupportRequestError(
                'Server sent error message: {}'.format(mo.group(1)))
        print("Deletion request for {} ({}) submitted.".format(
            machine_id, machine_address))
        if resp.text.find("You're almost done creating your request") < 0:
            print(
                "Warning: could not find the expected confirmation message "
                "in the support server's response.")

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import send [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 Session [as 别名]
# 或者: from requests.Session import send [as 别名]
    def __send_request(self, url, data=None, method='GET', isKeyRequired=True):
        if isKeyRequired and not self._key:
            raise Exception('API Key is required.  Get the API key from http://rimuhosting.com/cp/apikeys.jsp.  Then export RIMUHOSTING_APIKEY=xxxx (the digits only) or add RIMUHOSTING_APIKEY=xxxx to a ~/.rimuhosting file.')
        headers = {
            'Content-Type': 'application/json',
            'Accept': 'application/json'
        }
        if isKeyRequired:
            headers['Authorization']= "rimuhosting apikey=%s" % self._key
        
        url = urllib.parse.urljoin(self._base_url, url)

        data = data if isinstance(data, str) else json.dumps(data)

        s = Session()
        req = Request(method, url,
                      data=data,
                      headers=headers
                      )
        prepped = s.prepare_request(req)
        resp = s.send(prepped, timeout=3600)
        if not resp.ok:
            message = resp.text
            try: 
                j2 = resp.json()
                for val in j2:
                  if "error_info" in j2[val] and "human_readable_message" in j2[val]["error_info"]:
                      message = j2[val]["error_info"]["human_readable_message"]
                  break
            finally:
                raise Exception(resp.status_code, resp.reason, message)
        
        return resp

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import send [as 别名]
    def validate(self):
        """Run validation using HTTP requests against validation host

        Using rules provided by spec, perform requests against validation host
        for each rule. Request response is verified to match the spec respsonse
        rule.  This will yield either a :py:cls:`ValidationPass` or
        :py:cls:`ValidationFail` response.
        """
        session = Session()
        if not self.verify and hasattr(urllib3, 'disable_warnings'):
            urllib3.disable_warnings()
        for rule in self.spec.get_rules():
            req = rule.get_request(self.host, self.port)
            if self.debug:
                pprint.pprint(req.__dict__)
            try:
                resp = session.send(req.prepare(), allow_redirects=False,
                                    verify=self.verify)
                if self.debug:
                    pprint.pprint(resp.__dict__)
                if rule.matches(resp):
                    yield ValidationPass(rule=rule, request=req, response=resp)
            except (ConnectionError, SSLError) as exc:
                # No response yet
                yield ValidationFail(rule=rule, request=req, response=None,
                                     error=exc)
            except ValidationError as exc:
                # Response received, validation error
                yield ValidationFail(rule=rule, request=req, response=resp,
                                     error=exc)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import send [as 别名]
def main(args):
    if len(args) <= 1:
       print "Usage getentries.py startindex endindex"
       sys.exit(1)
    elif args[0].isdigit() == False or args[1].isdigit() == False:
       print "Usage getentries.py startindex endindex" 
       sys.exit(1)
    startindex = int(args[0])
    endindex = int(args[1])
    
    operation = 'ct/v1/get-entries'
    url = 'http://ct.googleapis.com/aviator/{}'.format(operation)
    
    
    params = urllib.urlencode({'start':startindex,'end':endindex - 1})
    
    s = Session()
    r = Request('GET',
    '{}?{}'.format(url,params),
    )
    
    prepped = r.prepare()
    r = s.send(prepped)
    if r.status_code == 200:
	entries = r.json()['entries']
	print entries
    else:
	print r.status_code
	print r.text

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import send [as 别名]
def main4():
    # http://stackoverflow.com/questions/10247054/http-post-and-get-with-cookies-for-authentication-in-python
    # auth_url3 = "https://sso-platform.syncapse-staging.com/ajax_request/[email protected]&password=Testing."
    # response_url = "https://manage.syncapse-staging.com/posts/responses"
    s = requests.Session()
    r1 = s.get(auth_url3)
    print r1.headers

    # working
    headers = {"Cookie": r1.headers["set-cookie"] + " ; company_guid=6f65b34d-b6f4-4abd-b14a-408b8a11029b"}

    s1 = Session()
    prepped = Request(
        "GET",  # or any other method, 'POST', 'PUT', etc.
        response_url,
        # data=data,
        headers=headers
        # ...
    ).prepare()

    resp = s1.send(prepped)

    WriteToFile("/home/rtandon/Downloads/Work/importdata/TCCC_Response/Response_Time_Json_Sample3_main4.txt", resp.text)

    #    print resp.text
    print "done"

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import send [as 别名]
    def handle(self, *args, **options):
        s = Session()
        if len(args) < 2:
            print "Usage: replay_error <host:port> <portable request>"
            sys.exit(1)

            # self.request('GET', '{base_url}/{url}'.format(
            #     base_url=self.base_url.rstrip('/'),
            #     url=url.lstrip('/'),
            # ),
            # params=params or {},
            # headers=self.base_headers,
            # cookies={
            #     'token': self.token or '',
            # }

        portable = json.loads(base64.b64decode(args[1]))
        req = Request(
            portable['method'],
            'http://{host}{path}'.format(
                host=args[0],
                path=portable['path'],
            ),
            params=portable['get'],
            data=portable['post'],
            cookies=portable['cookies'],
        ).prepare()
        res = s.send(req)
        print res.content

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import send [as 别名]
    def send_message(self, request):
        """Transport the message to the server and return the response.

        :param request: The JSON-RPC request string.
        :return: The response (a string for requests, None for notifications).
        """
        # Prepare the session
        session = Session()
        session_request = Request(method='POST', url=self.endpoint, \
            headers=self.headers, data=request, **self.requests_kwargs)
        prepared_request = session.prepare_request(session_request)
        prepared_request.headers = dict(list(dict(
            prepared_request.headers).items()) + list(self.headers.items()))
        # Log the request
        self.log_request(request, {'http_headers': prepared_request.headers})
        # Send the message
        try:
            response = session.send(prepared_request)
        except RequestException:
            session.close()
            raise
        session.close()
        # Log the response
        self.log_response(response.text, {'http_code': response.status_code, \
            'http_reason': response.reason, 'http_headers': response.headers})
        return response.text

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import send [as 别名]
 def _ads_request(method, url, headers=None, data=None, url_params=None):
     logging.warn('Ads Request:%s' % url)
     s = Session()
     req = Request(string.upper(method), url, headers=headers, data=data, params=url_params)
     prepped = req.prepare()
     rsp = s.send(prepped)
     return rsp.text