Python Session.request方法代码示例

# 需要导入模块: 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],
        })

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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)

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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)

# 需要导入模块: 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

# 需要导入模块: 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)

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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))
        )

# 需要导入模块: 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