Python Session.prepare_request方法代码示例

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import prepare_request [as 别名]
def send_request(method, url, payload=None, headers=None, client=None):

    if ( client == None ):
        s = Session()
        s.mount('https://', SSLAdapter('TLSv1'))
    elif ( clients.get(client, False) ):
        s = clients[client]
    else:
        s = Session()
        s.mount('https://', SSLAdapter('TLSv1'))
        clients[client] = s

    if ( payload == None ):
        request = Request(method, url, headers=headers)
        r = s.prepare_request(request)
    else:
        if ( headers == None ):
            headers = {}
        request = Request(method, url,
            data=json.dumps(payload), headers=headers)
        r = s.prepare_request(request)

    try:
        response = s.send(r, verify=False, timeout=1)
    except Timeout, SSLError:
        return send_request(method, url, payload, client)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import prepare_request [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 prepare_request [as 别名]
def get_scigraph_diff(scigraph_prod: str, scigraph_dev: str,
                      conf: dict, query_name: str) -> str:
    output_md = str()
    prod_results = get_scigraph_results(scigraph_prod, conf['query'])
    dev_results = get_scigraph_results(scigraph_dev, conf['query'])
    if prod_results == 'timeout' or dev_results == 'timeout':
        formatted_diff = {"request timeout": '0'}
    else:
        diff = diff_facets(dev_results, prod_results)
        formatted_diff = convert_diff_to_md(diff)

    output_md += "{}\n".format(add_md_header(query_name, 4))

    params = {
        'cypherQuery': conf['query']
    }

    sesh = Session()
    prod_req = sesh.prepare_request(Request('GET', scigraph_prod, params=params))
    dev_req = sesh.prepare_request(Request('GET', scigraph_dev, params=params))

    output_md += add_href(prod_req.url, "Production Query")
    output_md += '\n\n'
    output_md += add_href(dev_req.url, "Dev Query")
    output_md += '\n\n'

    diff_list = [(k, v) for k, v in formatted_diff.items()]
    diff_list.sort(key=lambda tup: int(re.search(r'\d+', tup[1]).group(0)), reverse=True)
    output_md += add_md_table(diff_list, conf['headers'])
    output_md += "\n\n"

    return output_md

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import prepare_request [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 prepare_request [as 别名]
    def recognize_captcha(self, str_image_path):
        # CAPTCHA画像の読み込み
        bin_captcha = open(str_image_path, 'rb').read()

        # base64でCAPTCHA画像をエンコード
        str_encode_file = base64.b64encode(bin_captcha).decode()

        # APIのURLを指定
        str_url = "https://vision.googleapis.com/v1/images:annotate?key="

        # 事前に取得したAPIキー
        str_api_key = ""

        # Content-TypeをJSONに設定
        str_headers = {'Content-Type': 'application/json'}

        # Cloud Vision APIの仕様に沿ってJSONのペイロードを定義。
        # CAPTCHA画像からテキストを抽出するため、typeは「TEXT_DETECTION」にする。
        str_json_data = {
            'requests': [
                {
                    'image': {
                        'content': str_encode_file
                    },
                    'features': [
                        {
                            'type': "LABEL_DETECTION",
                            'maxResults': 10
                        }
                    ]
                }
            ]
        }

        # リクエスト送信
        obj_session = Session()
        obj_request = Request("POST",
                              str_url + str_api_key,
                              data=json.dumps(str_json_data),
                              headers=str_headers
                              )
        obj_prepped = obj_session.prepare_request(obj_request)
        obj_response = obj_session.send(obj_prepped,
                                        verify=True,
                                        timeout=60
                                        )

        # 分析結果の取得
        if obj_response.status_code == 200:
            #logging
            logging.basicConfig(filename='example.log', level=logging.DEBUG)
            logging.debug(obj_response.text)
            #1番目のみを取得
            obj = obj_response.text
            keywords = json.loads(obj)
            keyword = keywords['responses'][0]['labelAnnotations'][0]['description']
            print("Tag:" + keyword)
            return(keyword)
        else:
            return "error"

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import prepare_request [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 prepare_request [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 prepare_request [as 别名]
def send_api_request(method, components, json_data=None, token=None, query=None):
    components = [str(v) for v in components]
    url = "http://" + default_host + "/" + "/".join(components)
    query = query if query is not None else {}
    if token is not None:
        query.update({"token": token})
    if query != {}:
        url += "?" + urllib.parse.urlencode(query)
    if json_data is not None:
        json_data = json.dumps(json_data)

    s = Session()
    req = Request(method=method, url=url, data=json_data)
    prepped = s.prepare_request(req)

    resp = s.send(prepped)

    if resp.status_code != 200 and resp.status_code != 400:
        print("bad response", resp.content.decode("utf-8"))
        raise Exception("Received bad status code {}".format(resp.status_code))

    json_data = resp.json()
    if json_data["result"] != 0:
        print("Received bad status code {} with response {}".format(json_data["result"], json_data))
    return resp.json()

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import prepare_request [as 别名]
def ticket_request():
    url = 'http://www.hbcredit.gov.cn/vote/vote/addAmount'
    ip_ran = inet_ntoa(pack('>I', randint(1, 0xffffffff)))  
    heads = {'X-Forwarded-For' :  ip_ran,
             'Accept':'application/json, text/javascript, */*; q=0.01',
             'Accept-Encoding':'gzip, deflate',
             'Accept-Language':'zh-CN,zh;q=0.8,en;q=0.6',
             'Connection':'keep-alive',
             'Content-Length':'13',
             'Content-Type':'application/x-www-form-urlencoded; charset=UTF-8',
             'Host':'www.hbcredit.gov.cn',
             'Origin':'http://www.hbcredit.gov.cn',
             'Referer':'http://www.hbcredit.gov.cn/ztzl/zxbwx/',
             'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36',
             'X-Requested-With':'XMLHttpRequest'
             } 
    datas = {'selectid': '2049'}
    s = Session()
    req = Request('POST', url = url , headers = heads, data = datas)
    prereq = s.prepare_request(req)
    try:
        send_req = s.send(prereq)
    except:
        pass
    return send_req.status_code,  send_req.content   

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import prepare_request [as 别名]
def post(message, token):
    data = {'text': message}
    s = Session()
    req = Request('POST', _SERVER, json=data)
    prepped = s.prepare_request(req)
    prepped.headers['X-Messaging-Token'] = token
    resp = s.send(prepped)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import prepare_request [as 别名]
    def from_url(cls, url, tokenizer):
        headers = {
            'User-Agent': ' '.join([
                'Mozilla/5.0 (X11; Linux x86_64)',
                'AppleWebKit/537.11 (KHTML, like Gecko)',
                'Chrome/23.0.1271.64 Safari/537.11'
            ]),
            'Accept': ','.join([
                'text/html', 'application/xhtml+xml', 'application/xml;q=0.9',
                '*/*;q=0.8'
            ]),
            'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
            'Accept-Encoding': 'none',
            'Accept-Language': 'en-US,en;q=0.8',
            'Connection': 'keep-alive'
        }
        session = Session()

        session.mount('http://', HTTPAdapter(max_retries=2))
        session.mount('https://', HTTPAdapter(max_retries=2))

        cookies = CookieJar()
        request = Request(method='GET',
                          url=url,
                          headers=headers,
                          cookies=cookies)
        prepare = session.prepare_request(request)
        response = session.send(prepare, verify=True)

        if response.status_code != requests.codes.ok:
            response.raise_for_status()

        return cls(response.text, tokenizer, url)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import prepare_request [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 prepare_request [as 别名]
    def ImageDetection(self, str_image_path):
        
    
        # 画像の読み込み。
        bin_image = open(str_image_path, 'rb').read()
        
        # base64エンコード。
        str_encode_file = base64.b64encode(bin_image)
        
        # APIのURL指定。
        str_url = "https://vision.googleapis.com/v1/images:annotate?key="
        
        # Content-Type の設定。
        str_headers = {'Content-Type': 'application/json'}
        
        # ペイロードの設定。
        str_json_data = {
            'requests': [
                {
                    'image': {
                        'content': str_encode_file 
                    },
                    'features': [
                        {
                            'type': "LABEL_DETECTION",
                            'maxResults': 10
                        },
                        {
                            'type': "SAFE_SEARCH_DETECTION",
                            'maxResults': 3
                            
                        }
                    ]
                }
            ]
        }
        
        # API_KEY の取得
        #  API キーは、git 管理外にするため、config ファイルとして外部化している。
        inifile = ConfigParser.SafeConfigParser()
        inifile.read("./config.ini")
        API_KEY = inifile.get("settings", "API_KEY")
        
        # リクエスト送信。
        obj_session = Session()
        obj_request = Request("POST",
                str_url + API_KEY,
                data = json.dumps(str_json_data),
                headers = str_headers
                )
        obj_prepped = obj_session.prepare_request(obj_request)
        obj_response = obj_session.send(obj_prepped, verify=True, timeout = 60) 
        
        # 分析結果の取得
        if obj_response.status_code == 200:
#            print obj_response.text
            return obj_response.text
        else:
            return "error:" + str(obj_response.status_code)

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import prepare_request [as 别名]
    def _get_feed(self):
        """Requests the Atom feed from Google"""
        authorization = self._get_credentials()
        session = Session()
        request = Request('GET', self.uri, auth=HTTPBasicAuth(*authorization))
        prepped = session.prepare_request(request)

        return session.send(prepped).text.encode('utf-8')

# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import prepare_request [as 别名]
class Client(BaseClient):
    """ Client implementation based on requests
    """

    __schemes__ = set(['http', 'https'])

    def __init__(self, auth=None, send_opt=None):
        """ constructor

        :param auth pyswagger.SwaggerAuth: auth info used when requesting
        :param send_opt dict: options used in requests.send, ex verify=False
        """
        super(Client, self).__init__(auth)
        if send_opt is None:
            send_opt = {}

        self.__s = Session()
        self.__send_opt = send_opt

    def request(self, req_and_resp, opt=None):
        """
        """
        if opt is None:
            opt = {}

        req, resp = super(Client, self).request(req_and_resp, opt)

        # apply request-related options before preparation.
        req.prepare(scheme=self.prepare_schemes(req).pop(), handle_files=False)
        req._patch(opt)

        # prepare for uploaded files
        file_obj = {}
        for k, v in six.iteritems(req.files):
            f = v.data or open(v.filename, 'rb')
            if 'Content-Type' in v.header:
                file_obj[k] = (v.filename, f, v.header['Content-Type'])
            else:
                file_obj[k] = (v.filename, f)

        rq = Request(
            method=req.method.upper(),
            url=req.url,
            params=req.query,
            data=req.data,
            headers=req.header,
            files=file_obj
        )
        rq = self.__s.prepare_request(rq)
        rs = self.__s.send(rq, stream=True, **self.__send_opt)

        resp.apply_with(
            status=rs.status_code,
            header=rs.headers,
            raw=six.BytesIO(rs.content).getvalue()
        )

        return resp