Python FuturesSession.request方法代码示例

# 需要导入模块: from requests_futures.sessions import FuturesSession [as 别名]
# 或者: from requests_futures.sessions.FuturesSession import request [as 别名]
class ConfluenceFuturesAPI(ConfluenceAPI):
    def __init__(self, username, password, uri_base, user_agent=ConfluenceAPI.DEFAULT_USER_AGENT,
                 executor=None, max_workers=10):
        """
        Initialize the async concurrent.futures API object.
        :param username: Your Confluence username.
        :param password: Your Confluence password.
        :param uri_base: The base url for your Confluence wiki (e.g. myorg.atlassian.com/wiki)
        :param user_agent: (Optional): The user-agent you wish to send on requests to the API.
                           DEFAULT: PythonConfluenceAPI.
        :param executor: (Optional): The concurrent.futures executor to power the API calls. Default: None, create a
                         new ThreadPoolExecutor.
        :param max_workers: (Optional): If the executor is not specified and the default ThreadPoolExecutor is spawned,
                            this specifies the number of worker threads to create.
        """
        super(ConfluenceFuturesAPI, self).__init__(username, password, uri_base, user_agent)
        self.executor = executor
        self.max_workers = max_workers

    def _start_http_session(self):
        """
        Start a new requests HTTP session, clearing cookies and session data.
        :return: None
        """
        api_logger.debug("Starting new HTTP session...")
        self.session = FuturesSession(executor=self.executor, max_workers=self.max_workers)
        self.session.headers.update({"User-Agent": self.user_agent})
        if self.username and self.password:
            api_logger.debug("Requests will use authorization.")
            self.session.auth = HTTPBasicAuth(self.username, self.password)

    def _service_request(self, request_type, sub_uri, params=None, callback=None,
                         raise_for_status=True, raw=False, **kwargs):
        """
        Base method for handling HTTP requests via the current requests session.
        :param request_type: The request type as a string (e.g. "POST", "GET", "PUT", etc.)
        :param sub_uri: The REST end point (sub-uri) to communicate with.
        :param params: (Optional) HTTP Request parameters. Default: none
        :param callback: (Optional) A callback function to be excuted on the resulting requests response.
                         This synchronous implementation will return the results of the callback.
                         Default: None. This method returns either the decoded JSON or the raw request content.
        :param raise_for_status: (Optional) When set True, we raise requests.HTTPError on 4xx or 5xx status. When
                                 set False, non-2xx/3xx status code is ignored. Default: True
        :param raw: (Optional) If no callback is set, return the raw content from the request if this is set True.
                    If False, the method attempts to parse the request as JSON data and return the resutls.
                    Default: False
        :param kwargs: Additional parameters to pass to the session request call.
        :return: The concurrent.futures object that holds the future for the API method call.
        """
        api_logger.debug("Sending request: {} ({})".format(sub_uri, request_type))
        if not self.session:
            self._start_http_session()
        uri = urljoin(self.uri_base, sub_uri)
        if params:
            kwargs.update(params=params)
        if callback:
            def base_callback(_, response):
                if raise_for_status:
                    response.raise_for_status()
                return callback(response)
        else:
            def base_callback(_, response):
                if raise_for_status:
                    response.raise_for_status()
                return response.content if raw else json.loads(response.text)
        response_future = self.session.request(request_type, uri, background_callback=base_callback, **kwargs)
        return response_future

# 需要导入模块: from requests_futures.sessions import FuturesSession [as 别名]
# 或者: from requests_futures.sessions.FuturesSession import request [as 别名]
class HackerOneClient(object):
    BASE_URL = "https://api.hackerone.com/v1"
    REQUEST_HEADERS = {
        "User-Agent": "HackerOne Python Client v" + __version__,
    }

    def __init__(self, identifier, token):
        self.identifier = identifier
        self.token = token
        self._init_session()

    def _init_session(self):
        self.s = FuturesSession()
        self.s.headers.update(self.REQUEST_HEADERS)
        self.s.auth = HTTPBasicAuth(self.identifier, self.token)

    def make_request(self, url, params=None, data=None, method=None):
        if method is None:
            method = "GET"
        if not url.startswith("http"):
            url = self.BASE_URL + url
        if isinstance(params, dict):
            params = encode_params(params)

        return self.s.request(method, url, params=params, data=data)

    def request_json(self, url, params=None, data=None, method=None):
        r = self.make_request(url, params, data, method).result()
        r.raise_for_status()
        return r.json()

    def request_object(self, url, params=None, data=None, method=None):
        data = self.request_json(url, params, data, method)["data"]
        # If we're fetching a single object make sure that consumers
        # know this is the canonical version
        data["_canonical"] = True
        return hydrate_object(data, self)

    def request_paginated_objects(self, url, params=None, yield_pages=False):
        future = self.make_request(url, params)
        res_iter = self._request_paginated_inner(url, future, yield_pages)
        return LazyListing(res_iter)

    def _request_paginated_inner(self, url, future, yield_pages):
        while url:
            resp = future.result()
            resp.raise_for_status()
            parsed = resp.json()
            url = parsed["links"].get('next')
            if url:
                future = self.make_request(url)

            hydrated_objs = hydrate_objects(parsed["data"], self)
            if yield_pages:
                yield hydrated_objs
            else:
                for obj in hydrated_objs:
                    yield obj

    def get_resource(self, rsrc_type, obj_id):
        return rsrc_type.get(self, obj_id)

    def find_resources(self, rsrc_type, sort=None, yield_pages=False, **kwargs):
        """Find instances of `rsrc_type` that match the filter in `**kwargs`"""
        return rsrc_type.find(self, sort=sort, yield_pages=yield_pages, **kwargs)