Initial

Author: Mikhail Pyrev

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+.idea/
+/build/
+/dist/
+*.sqlite3
+local_settings.py
+*.egg-info/

LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Mikhail Pyrev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,15 @@
+python-capitalist
+=================
+
+A little client for API of [capitalist.net](https://capitalist.net/).
+
+Couple of API methods are implemented because I need only them.
+Feel free to ask for additional methods. I'll look into it.
+
+`import_batch_advanced` DOES NOT support certificates with passphrase.
+
+
+LICENSE
+-------
+
+MIT

capitalist/__init__.py

@@ -0,0 +1,2 @@
+from .capitalist import Capitalist
+from .const import __version__

capitalist/auth.py

@@ -0,0 +1,72 @@
+from base64 import b64encode
+
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import serialization, hashes
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.hazmat.primitives.asymmetric.rsa import RSAPublicNumbers
+
+from .exceptions import RequestException
+from .utils import retry
+
+
+class Authenticator:
+    def __init__(self, request_executor, login, password):
+        self.request_executor = request_executor
+        self.login = login
+        self.password = password
+        self._encrypted_password = None
+        self._token = None
+
+    @retry((RequestException,))
+    def _get_token(self):
+        data = {
+            'operation': 'get_token',
+            'login': self.login,
+        }
+        json_data = self.request_executor.request(data=data)
+        return json_data
+
+    def setup(self):
+        token_response = self._get_token()
+        self._token = token_response['data']['token']
+        self._encrypted_password = EncryptedPassword(
+            self.password, token_response['data']['modulus'], token_response['data']['exponent'])
+
+    @property
+    def encrypted_password(self):
+        if self._encrypted_password is None:
+            self.setup()
+        return self._encrypted_password
+
+    @property
+    def token(self):
+        if self._token is None:
+            self.setup()
+        return self._token
+
+
+class EncryptedPassword:
+    """
+    PKCS1 v1.5 encrypted password.
+    """
+
+    def __init__(self, password, modulus, exponent):
+        self._password = password.encode('utf-8')
+        modulus = int(modulus, 16)
+        exponent = int(exponent, 16)
+        public_numbers = RSAPublicNumbers(exponent, modulus)
+        self.public_key = public_numbers.public_key(default_backend())
+
+    @property
+    def password(self):
+        return self.public_key.encrypt(self._password, padding.PKCS1v15()).hex()
+
+
+class Signer:
+    def __init__(self, private_key: bytes):
+        self._key = serialization.load_pem_private_key(private_key, None, default_backend())
+
+    def sign(self, message):
+        signature = self._key.sign(message, padding.PKCS1v15(), hashes.SHA1())
+        signature = b64encode(signature)
+        return signature

capitalist/capitalist.py

@@ -0,0 +1,89 @@
+from decimal import Decimal
+from pathlib import Path
+from typing import Union
+
+from capitalist.exceptions import ResponseException
+from capitalist.models import Account, CurrencyRate
+from .auth import Authenticator, Signer
+from .exceptions import RequestException, ImproperlyConfigured
+from .request_executor import RequestExecutor
+from .utils import retry
+
+
+class Capitalist:
+    def __init__(
+            self,
+            login,
+            password,
+            request_executor_class=RequestExecutor,
+            authenticator_class=Authenticator,
+            signer_class=Signer,
+            private_key: Union[bytes, Path] = None,
+    ):
+        self.login = login
+        self.request_executor = request_executor_class()
+        self.authenticator = authenticator_class(self.request_executor, login, password)
+        self.signer = None
+        if private_key is not None:
+            if isinstance(private_key, Path):
+                private_key = private_key.read_bytes()
+            self.signer = signer_class(private_key)
+
+    @retry((RequestException,))
+    def secure_request(self, operation, data=None, **kwargs):
+        if data is None:
+            data = {}
+        data.update({
+            'operation': operation,
+            'login': self.login,
+            'token': self.authenticator.token,
+            'encrypted_password': self.authenticator.encrypted_password.password,
+        })
+        kwargs['data'] = data
+        response_json = self.request_executor.request(**kwargs)
+        code = response_json['code']
+        if code != 0:
+            raise ResponseException(code, response_json['message'])
+        return response_json
+
+    def accounts(self):
+        json_data = self.secure_request('get_accounts')
+        return [Account.parse_json(acc_json) for acc_json in json_data['data']['accounts']]
+
+    def currency_rates(self):
+        json_data = self.secure_request('currency_rates')['data']['rates']
+        rates = []
+        for type_ in CurrencyRate.TYPES:
+            for rate_data in json_data[type_]:
+                rates.append(CurrencyRate.parse_json(rate_data, type_=type_))
+        return rates
+
+    def import_batch_advanced(self, payments, account_rur, account_usd, account_eur, account_btc):
+        if self.signer is None:
+            raise ImproperlyConfigured('Provide private key and/or passphrase to be able to sign data.')
+
+        payment_data = '\n'.join([payment.as_batch_record() for payment in payments])
+        data = {
+            'batch': payment_data,
+            'verification_type': 'SIGNATURE',
+            'verification_data': self.signer.sign(payment_data.encode('utf-8')),
+            'account_RUR': account_rur,
+            'account_USD': account_usd,
+            'account_EUR': account_eur,
+            'account_BTC': account_btc,
+        }
+        return self.secure_request('import_batch_advanced', data)
+
+    def get_document_fee(
+            self, document_type: str, source_account: str, amount: Decimal, dest_account: str = None,
+            wiretag: str = None):
+        data = {
+            'document_type': document_type,
+            'source_account': source_account,
+            'amount': amount,
+        }
+        if dest_account:
+            data['dest_account'] = dest_account
+        if wiretag:
+            data['wiretag'] = wiretag
+        return self.secure_request('get_document_fee', data)

capitalist/const.py

@@ -0,0 +1,4 @@
+__version__ = '1.0.0'
+
+TIMEOUT = 15
+API_URL = 'https://api.capitalist.net'