本文整理汇总了Python中requests.Session.request方法的典型用法代码示例。如果您正苦于以下问题:Python Session.request方法的具体用法?Python Session.request怎么用?Python Session.request使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类requests.Session
的用法示例。
在下文中一共展示了Session.request方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: Gateway
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
class Gateway(Mapping):
def __init__(self, baseurl, login, password):
self.baseurl = baseurl
self.login = login
self.password = password
self.session = Session()
def __iter__(self):
return iter(KINDS)
def __getitem__(self, key):
if not key in self:
raise KeyError(key)
return Spooler(key, self)
def __contains__(self, key):
return key in iter(self)
def __len__(self):
return len(iter(self))
def request(self, method, url, **kw):
url = urljoin(self.baseurl, url)
r = self.session.request(method, url, auth=(self.login, self.password), **kw)
return r.json()
def to_dict(self):
return {k: dict(v) for k, v in self.iteritems()}
def send(self, number, text):
return self.request('POST', 'outgoing', json={
'text': text,
'mobiles': [number],
})
示例2: get_response
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
def get_response(name, request_kwargs):
host = Host(request_kwargs['headers'].get('Host', None)
or urlparse(request_kwargs['url']).netloc.split('@')[-1])
session = Session(host, name)
session.load()
# Update session headers with the request headers.
session['headers'].update(request_kwargs.get('headers', {}))
# Use the merged headers for the request
request_kwargs['headers'] = session['headers']
auth = request_kwargs.get('auth', None)
if auth:
session.auth = auth
elif session.auth:
request_kwargs['auth'] = session.auth
rsession = RSession(cookies=session.cookies)
try:
response = rsession.request(**request_kwargs)
except Exception:
raise
else:
session.cookies = rsession.cookies
session.save()
return response
示例3: request
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
def request(self, method, url, *args, **kwargs):
acceptable_status = kwargs.pop("acceptable_status", [])
exception = kwargs.pop("exception", PluginError)
headers = kwargs.pop("headers", {})
params = kwargs.pop("params", {})
proxies = kwargs.pop("proxies", self.proxies)
raise_for_status = kwargs.pop("raise_for_status", True)
schema = kwargs.pop("schema", None)
session = kwargs.pop("session", None)
timeout = kwargs.pop("timeout", self.timeout)
if session:
headers.update(session.headers)
params.update(session.params)
try:
res = Session.request(self, method, url,
headers=headers,
params=params,
timeout=timeout,
proxies=proxies,
*args, **kwargs)
if raise_for_status and res.status_code not in acceptable_status:
res.raise_for_status()
except (RequestException, IOError) as rerr:
err = exception("Unable to open URL: {url} ({err})".format(url=url,
err=rerr))
err.err = rerr
raise err
if schema:
res = schema.validate(res.text, name="response text", exception=PluginError)
return res
示例4: request
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
def request(self, method, url, *args, **kwargs):
exception = kwargs.pop("exception", PluginError)
headers = kwargs.pop("headers", {})
params = kwargs.pop("params", {})
proxies = kwargs.pop("proxies", self.proxies)
session = kwargs.pop("session", None)
timeout = kwargs.pop("timeout", self.timeout)
if session:
headers.update(session.headers)
params.update(session.params)
try:
res = Session.request(self, method, url,
headers=headers,
params=params,
timeout=timeout,
proxies=proxies,
*args, **kwargs)
res.raise_for_status()
except (RequestException, IOError) as rerr:
err = exception("Unable to open URL: {url} ({err})".format(url=url,
err=rerr))
err.err = rerr
raise err
return res
示例5: HttpExecutor
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
class HttpExecutor(object):
"""Handles the actual HTTP requests to the Stormpath service.
It uses the Requests library: http://docs.python-requests.org/en/latest/.
The HttpExecutor, along with :class:`stormpath.cache.manager.CacheManager`
is a part of the :class:`stormpath.data_store.DataStore`.
:param base_url: The root of the Stormpath service.
Paths to specific resources will be prepended by this url.
:param auth: Authentication manager, like
:class:`stormpath.auth.Sauthc1Signer`.
"""
USER_AGENT = 'Stormpath-PythonSDK/' + STORMPATH_VERSION
def __init__(self, base_url, auth, proxies=None):
self.base_url = base_url
self.session = Session()
self.session.proxies = proxies or {}
self.session.auth = auth
self.session.headers.update({
'Accept': 'application/json',
'Content-Type': 'application/json',
'User-Agent': self.USER_AGENT,
})
def request(self, method, url, data=None, params=None):
if params:
params = OrderedDict(sorted(params.items()))
if not url.startswith(self.base_url):
url = self.base_url + url
try:
r = self.session.request(method, url, data=data, params=params,
allow_redirects=False)
except Exception as ex:
raise Error({'developerMessage': str(ex)})
if r.status_code in [301, 302] and 'location' in r.headers:
return self.request('GET', r.headers['location'], params=params)
if r.status_code >= 400 and r.status_code <= 600:
raise Error(r.json(), http_status=r.status_code)
try:
return r.json()
except:
return {}
def get(self, url, params=None):
return self.request('GET', url, params=params)
def post(self, url, data, params=None):
return self.request('POST', url, data=dumps(data), params=params)
def delete(self, url):
return self.request('DELETE', url)
示例6: request
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
def request(self, method, url, *args, **kwargs):
headers = kwargs.pop("headers", None)
if headers:
for i in headers.keys():
self.headers[i] = headers[i]
logging.debug("HTTP getting %r", url)
res = Session.request(self, method, url, verify=self.verify, proxies=self.proxy, *args, **kwargs)
return res
示例7: request
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
def request(self, method, url, *args, **kwargs):
log.debug("HTTP getting %r", url)
starttime = time.time()
res = Session.request(self, method, url, **kwargs)
spent_time = time.time() - starttime
bps = 8 * len(res.content) / max(spent_time, 0.001)
log.debug("HTTP got %d bytes from %r in %.2fs (= %dbps)", len(res.content), url, spent_time, bps)
return res
示例8: func
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
def func():
try:
background_callback = kwargs.pop('background_callback', None)
res = requestsSession.request(self, *args, **kwargs)
if background_callback is not None:
res = background_callback(self, res)
reactor.callFromThread(d.callback, res)
except Exception as e:
reactor.callFromThread(d.errback, e)
示例9: request
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
def request(self, method, url, *args, **kwargs):
headers = kwargs.pop("headers", None)
if headers:
headers["User-Agent"] = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.101 Safari/537.3"
else:
headers = {"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.101 Safari/537.3"}
log.debug("HTTP getting %r", url)
res = Session.request(self, method, url, headers=headers, *args, **kwargs)
return res
示例10: func
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
def func(d):
"""Callbacks the deferred d upon request completion/error.
"""
try:
background_callback = kwargs.pop('background_callback', None)
res = requestsSession.request(self, *args, **kwargs)
if background_callback is not None:
res = background_callback(self, res)
reactor.callFromThread(d.callback, res)
except Exception as e:
reactor.callFromThread(d.errback, e)
示例11: AsyncRequest
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
class AsyncRequest(object):
""" Asynchronous request.
Accept same parameters as ``Session.request`` and some additional:
:param session: Session which will do request
:param callback: Callback called on response.
Same as passing ``hooks={'response': callback}``
"""
def __init__(self, method, url, **kwargs):
#: Request method
self.method = method
#: URL to request
self.url = url
#: Associated ``Session``
self.session = kwargs.pop('session', None)
if self.session is None:
self.session = Session()
callback = kwargs.pop('callback', None)
if callback:
kwargs['hooks'] = {'response': callback}
#: The rest arguments for ``Session.request``
self.kwargs = kwargs
#: Resulting ``Response``
self.response = None
self.error = None
self.name = None
self.waiting_status_code = None
self.check_text = self.check_html = None
def send(self, **kwargs):
"""
Prepares request based on parameter passed to constructor and optional ``kwargs```.
Then sends request and saves response to :attr:`response`
:returns: ``Response``
"""
merged_kwargs = {}
merged_kwargs.update(self.kwargs)
merged_kwargs.update(kwargs)
try:
self.response = self.session.request(self.method,
self.url, **merged_kwargs)
except Exception as e:
self.response = None
self.error = e
log.exception("[%s] gave exception" % self.url)
return
return self.response
def __repr__(self):
return "<AsyncRequest %s>" % self.url
示例12: Requester
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
class Requester(object):
def __init__(self, login_or_token, password, base_url):
self.__base_url = base_url
self.__headers = {}
self.__headers["content-type"] = "application/json"
if login_or_token is not None and password is not None:
self.__headers["Authorization"] = "Basic " + base64.b64encode("%s:%s" % (login_or_token, password))
elif login_or_token is not None:
self.__headers["Authorization"] = "Token %s" % login_or_token
self.__session = Session()
def request(self, method, resource, data=None, headers=None, params=None):
if resource.startswith("/"):
url = self.__base_url + resource
else:
# TODO: Validate the URL is valid given base_url
url = resource
all_headers = {}
all_headers.update(self.__headers)
if headers is not None:
all_headers.update(headers)
if data is not None:
data = json.dumps(data, default=json_serial)
# TODO: try..except
response = self.__session.request(url=url, method=method, params=params, data=data, headers=all_headers)
if response.status_code == 400:
raise BadRequestException(method, url, params, data, all_headers, response)
elif 400 < response.status_code < 500:
if response.status_code == 401:
raise UnauthorizedException(method, url, params, data, all_headers, response)
if response.status_code == 404:
raise UnknownObjectException(method, url, params, data, all_headers, response)
else:
raise ChisubmitRequestException(method, url, params, data, all_headers, response)
elif 500 <= response.status_code < 600:
raise ChisubmitRequestException(method, url, params, data, all_headers, response)
try:
response_data = response.json()
except ValueError:
response_data = {"data": response.text}
return response.headers, response_data
示例13: AsyncRequest
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
class AsyncRequest(object):
""" Asynchronous request.
Accept same parameters as ``Session.request`` and some additional:
:param session: Session which will do request
:param callback: Callback called on response.
Same as passing ``hooks={'response': callback}``
"""
def __init__(self, method, url, **kwargs):
#: Request method
self.method = method
#: URL to request
self.url = url
#: Associated ``Session``
self.session = kwargs.pop('session', None)
if self.session is None:
self.session = Session()
# Added a kwargs (the 'source') to be able to map the request back to it's source object
#: Source of the request
self.source = kwargs.pop('source', None)
callback = kwargs.pop('callback', None)
if callback:
kwargs['hooks'] = {'response': callback}
#: The rest arguments for ``Session.request``
self.kwargs = kwargs
#: Resulting ``Response``
self.response = None
def send(self, **kwargs):
"""
Prepares request based on parameter passed to constructor and optional ``kwargs```.
Then sends request and saves response to :attr:`response`
:returns: ``Response``
"""
merged_kwargs = {}
merged_kwargs.update(self.kwargs)
merged_kwargs.update(kwargs)
try:
self.response = self.session.request(self.method, self.url, **merged_kwargs)
# Add the source in the response object to be able to map it back to the source object
self.response.source = self.source
except Exception as e:
self.exception = e
return self
示例14: _request
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
def _request(self, method, end_point_url, params={}, files=None):
"""
Run requests for this sessions
:param method: can be one in [GET, POST, DELETE, PUT]
:param end_point_url: the end point name
:param params: (optional) additional parameters for the url
:param files: (optional) files to be uploaded
:return: a response (a dictionary) or raise an HutomaException
"""
session = Session()
session.headers['user_key'] = self._user_key
url = self._base_url + end_point_url.format(**params)
method = method.upper()
logging.debug('API call {0}: {1}'.format(method, end_point_url.format(**params)))
response = session.request(method=method,
url=url,
files=files,
timeout=None)
logging.debug(' Response: {0}'.format(response.__dict__))
self._api_calls += 1
if response.status_code >= 400:
raise HutomaException(
error_code=response.status_code,
error_details=response.raw,
message=response._content,
sender='_request {0} {1}'.format(method, end_point_url.format(**params))
)
response = json.loads(response.content)
logging.debug(' Response keys: {0}'.format(response.keys()))
logging.debug(' Response: {0}'.format(response))
if 'code' in response:
response = {'status': response}
if response['status']['code'] == 200:
# del response['status']
return response
raise HutomaException(
error_code=response['status']['code'],
error_type=response['status']['errorType'],
error_details=response['status']['errorDetails'],
sender='_request {0} {1}'.format(method, end_point_url.format(**params))
)
示例15: AsyncRequest
# 需要导入模块: from requests import Session [as 别名]
# 或者: from requests.Session import request [as 别名]
class AsyncRequest(object):
""" Asynchronous request.
Accept same parameters as ``Session.request`` and some additional:
:param session: Session which will do request
:param callback: Callback called on response.
Same as passing ``hooks={'response': callback}``
"""
def __init__(self, method, url, **kwargs):
#: Request method
self.method = method
#: URL to request
self.url = url
#: Associated ``Session``
self.session = kwargs.pop('session', None)
if self.session is None:
self.session = Session()
callback = kwargs.pop('callback', None)
if callback:
kwargs['hooks'] = {'response': callback}
self.exception_handler = kwargs.pop('exception_handler', None)
#: The rest arguments for ``Session.request``
self.kwargs = kwargs
#: Resulting ``Response``
self.response = None
def send(self, **kwargs):
"""
Prepares request based on parameter passed to constructor and optional ``kwargs```.
Then sends request and saves response to :attr:`response`
:returns: ``Response``
"""
merged_kwargs = {}
merged_kwargs.update(self.kwargs)
merged_kwargs.update(kwargs)
try:
self.response = self.session.request(self.method,
self.url, **merged_kwargs)
except Exception as e:
self.exception = e
self.traceback = traceback.format_exc()
if self.exception_handler:
self.exception_handler(self, self.exception)
return self