bitpay.Client

Complexity

Total Complexity

25

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

8 Methods

Rating	Name	Duplication	Size	Complexity
A	Client.verify_invoice_params()	0	7	3
A	Client.pair_pos_client()	0	19	4
A	Client.get_invoice()	0	13	3
B	Client.verify_tokens()	0	20	6
A	Client.create_token()	17	17	3
A	Client.response_error()	0	4	1
A	Client.token_from_response()	0	7	1
A	Client.create_invoice()	21	21	3

from bitpay_exceptions import *
import bitpay_key_utils as key_utils
import requests
import json
import re


class Client:

    def __init__(self, api_uri="https://bitpay.com", insecure=False,
                 pem=key_utils.generate_pem(), tokens={}):

        self.uri = api_uri
        self.verify = not(insecure)
        self.pem = pem
        self.client_id = key_utils.get_sin_from_pem(pem)
        self.tokens = tokens
        self.user_agent = 'bitpay-python'

    def pair_pos_client(self, code):
        """
        POST /tokens
        https://bitpay.com/api#resource-Tokens
        """
        if re.match("^\w{7,7}$", code) is None:
            raise BitPayArgumentError("pairing code is not legal")
        payload = {'id': self.client_id, 'pairingCode': code}
        headers = {"content-type": "application/json",
                   "accept": "application/json", "X-accept-version": "2.0.0"}
        try:
            response = requests.post(self.uri + "/tokens", verify=self.verify,
                                     data=json.dumps(payload), headers=headers)
        except Exception:
            raise BitPayConnectionError('Connection refused')
        if response.ok:
            self.tokens = self.token_from_response(response.json())
            return self.tokens
        self.response_error(response)

    def create_token(self, facade):

This code seems to be duplicated in your project.

        """
        POST /tokens
        https://bitpay.com/api#resource-Tokens
        """
        payload = {'id': self.client_id, 'facade': facade}
        headers = {"content-type": "application/json",
                   "accept": "application/json", "X-accept-version": "2.0.0"}
        try:
            response = requests.post(self.uri + "/tokens", verify=self.verify,
                                     data=json.dumps(payload), headers=headers)
        except Exception:
            raise BitPayConnectionError('Connection refused')
        if response.ok:
            self.tokens = self.token_from_response(response.json())
            return response.json()['data'][0]['pairingCode']
        self.response_error(response)

    def create_invoice(self, params):

This code seems to be duplicated in your project.

        """
        POST /invoices
        https://bitpay.com/api#resource-Invoices
        """
        self.verify_invoice_params(params['price'], params['currency'])
        payload = json.dumps(params)
        uri = self.uri + "/invoices"
        xidentity = key_utils.get_compressed_public_key_from_pem(self.pem)
        xsignature = key_utils.sign(uri + payload, self.pem)
        headers = {"content-type": "application/json",
                   "accept": "application/json", "X-Identity": xidentity,
                   "X-Signature": xsignature, "X-accept-version": "2.0.0"}
        try:
            response = requests.post(uri, data=payload, headers=headers,
                                     verify=self.verify)
        except Exception as pro:
            raise BitPayConnectionError(pro.args)
        if response.ok:
            return response.json()['data']
        self.response_error(response)

    def get_invoice(self, invoice_id):
        """
        GET /invoices/:invoiceId
        https://bitpay.com/api#resource-Invoices
        """
        uri = self.uri + "/invoices/" + invoice_id
        try:
            response = requests.get(uri, verify=self.verify)
        except Exception as pro:
            raise BitPayConnectionError(pro.args)
        if response.ok:
            return response.json()['data']
        self.response_error(response)

    def verify_tokens(self):
        """
        GET /tokens
        https://bitpay.com/api#resource-Tokens
        """
        xidentity = key_utils.get_compressed_public_key_from_pem(self.pem)
        xsignature = key_utils.sign(self.uri + "/tokens", self.pem)
        headers = {"content-type": "application/json",
                   "accept": "application/json", "X-Identity": xidentity,
                   "X-Signature": xsignature, "X-accept-version": '2.0.0'}
        response = requests.get(self.uri + "/tokens", headers=headers,
                                verify=self.verify)
        if response.ok:
            allTokens = response.json()['data']
            selfKeys = self.tokens.keys()
            matchedTokens = [token for token in allTokens for key in selfKeys
                             if token.get(key) == self.tokens.get(key)]
        if not matchedTokens:
            return False
        return True

    def token_from_response(self, responseJson):
        token = responseJson['data'][0]['token']
        facade = responseJson['data'][0]['facade']
        return {facade: token}
        raise BitPayBitPayError(
            '%(code)d: %(message)s' % {'code': response.status_code,
                                       'message': response.json()['error']})

    def verify_invoice_params(self, price, currency):
        if re.match("^[A-Z]{3,3}$", currency) is None:
            raise BitPayArgumentError("Currency is invalid.")
        try:
            float(price)
        except:
            raise BitPayArgumentError("Price must be formatted as a float")

    def response_error(self, response):
        raise BitPayBitPayError(
            '%(code)d: %(message)s' % {'code': response.status_code,
                                       'message': response.json()['error']})