コード例 #1
0
        call_options = options.copy()
        limit = options['limit']
        results: Union[List[Trade], List[AssetMovement]] = []  # type: ignore # bug list nothing
        processed_result_ids: Set[int] = set()
        retries_left = API_REQUEST_RETRY_TIMES
        while retries_left >= 0:
            response = self._api_query(
                endpoint=endpoint,
                options=call_options,
            )
            if response.status_code != HTTPStatus.OK:
                try:
                    error_response = json.loads(response.text)
                except JSONDecodeError:
                    msg = f'{self.name} {case} returned an invalid JSON response: {response.text}.'
                    log.error(msg, options=call_options)
                    self.msg_aggregator.add_error(
                        f'Got remote error while querying {self.name} {case}: {msg}',
                    )
                    return []  # type: ignore # bug list nothing

                # Check if the rate limits have been hit (response JSON as dict)
                if isinstance(error_response, dict):
                    if error_response.get('error', None) == API_RATE_LIMITS_ERROR_MESSAGE:
                        if retries_left == 0:
                            msg = (
                                f'{self.name} {case} request failed after retrying '
                                f'{API_REQUEST_RETRY_TIMES} times.'
                            )
                            self.msg_aggregator.add_error(
                                f'Got remote error while querying {self.name} {case}: {msg}',
コード例 #2
0
ファイル: bitstamp.py プロジェクト: sveitser/rotki
        while True:
            response = self._api_query(
                endpoint=endpoint,
                method='post',
                options=call_options,
            )
            if response.status_code != HTTPStatus.OK:
                return self._process_unsuccessful_response(
                    response=response,
                    case=response_case,
                )
            try:
                response_list = rlk_jsonloads_list(response.text)
            except JSONDecodeError:
                msg = f'Bitstamp returned invalid JSON response: {response.text}.'
                log.error(msg)
                self.msg_aggregator.add_error(
                    f'Got remote error while querying Bistamp trades: {msg}',
                )
                no_results: Union[List[Trade], List[AssetMovement]] = []  # type: ignore
                return no_results

            has_results = False
            is_result_timesamp_gt_end_ts = False
            result: Union[Trade, AssetMovement]
            for raw_result in response_list:
                if raw_result['type'] not in raw_result_type_filter:
                    continue
                try:
                    result_timestamp = deserialize_timestamp_from_bitstamp_date(
                        raw_result['datetime'],
コード例 #3
0
ファイル: kucoin.py プロジェクト: rotki/rotki
            response = self._api_query(
                case=case,
                options=call_options,
            )
            if response.status_code != HTTPStatus.OK:
                return self._process_unsuccessful_response(
                    response=response,
                    case=case,
                )

            try:
                response_dict = jsonloads_dict(response.text)
            except JSONDecodeError as e:
                msg = f'Kucoin {case} returned an invalid JSON response: {response.text}.'
                log.error(msg)
                self.msg_aggregator.add_error(
                    f'Got remote error while querying kucoin {case}: {msg}', )
                raise RemoteError(msg) from e

            try:
                response_data = response_dict['data']
                total_page = response_data['totalPage']
                current_page = response_data['currentPage']
                raw_results = response_data['items']
            except KeyError as e:
                msg = f'Kucoin {case} JSON response is missing key: {str(e)}'
                log.error(msg, response_dict)
                raise RemoteError(msg) from e

            for raw_result in raw_results: