mangopay4-python-sdk 4.0.0__py3-none-any.whl

mangopay/__init__.py

@@ -0,0 +1,35 @@
+client_id = None
+apikey = None
+api_url = 'https://api.mangopay.com/v2.01/'
+api_sandbox_url = 'https://api.sandbox.mangopay.com/v2.01/'
+temp_dir = None
+api_version = 2.01
+sandbox = True
+uk_header_flag = False
+mtls_cert = None  # Path to client certificate file for mTLS
+mtls_private_key = None  # Path to client private key file for mTLS
+
+package_version = None
+try:
+    # try importlib.metadata first
+    from importlib.metadata import version
+    package_version = version('mangopay4-python-sdk')
+except Exception:
+    # fallback for development/editable installs
+    try:
+        with open('./setup.py', 'r') as f:
+            for line in f:
+                if line.startswith('    version'):
+                    package_version = line.split('=')[1].replace("'", "").replace(",", "").replace("\n", "").strip()
+    except:
+        None
+
+
+from .api import APIRequest  # noqa
+from .utils import memoize
+
+
+def _get_default_handler():
+    return APIRequest()
+
+get_default_handler = memoize(_get_default_handler, {}, 0)

mangopay/api.py

@@ -0,0 +1,390 @@
+# -*- coding: utf-8 -*-
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import logging
+import platform
+import time
+
+import requests
+import six
+from requests.exceptions import ConnectionError, Timeout
+
+import mangopay
+from mangopay.auth import AuthorizationTokenManager
+from mangopay.ratelimit import RateLimit
+from .exceptions import APIError, DecodeError
+from .signals import request_finished, request_started, request_error
+from .utils import reraise_as
+
+try:
+    import urllib.parse as urlrequest
+except ImportError:
+    import urllib as urlrequest
+
+try:
+    import simplejson as json
+except ImportError:
+    import json
+
+
+logger = logging.getLogger('mangopay')
+
+rate_limits = None
+
+
+class APIRequest(object):
+
+    def __init__(self, client_id=None, apikey=None, api_url=None, api_sandbox_url=None, sandbox=None,
+                 timeout=30.0, storage_strategy=None, proxies=None, uk_header_flag=False,
+                 cert=None, key=None):
+        global rate_limits
+        rate_limits = None
+        if (sandbox is None and mangopay.sandbox) or sandbox:
+            self.api_url = api_sandbox_url or mangopay.api_sandbox_url
+        else:
+            self.api_url = api_url or mangopay.api_url
+
+        self.client_id = client_id or mangopay.client_id
+        self.apikey = apikey or mangopay.apikey
+        self.auth_manager = AuthorizationTokenManager(self, storage_strategy)
+        self.timeout = timeout
+        self.proxies = proxies
+        self.uk_header_flag = uk_header_flag or mangopay.uk_header_flag
+
+        self._session = requests.Session()
+
+        _cert = cert or mangopay.mtls_cert
+        _key = key or mangopay.mtls_private_key
+        if _cert and _key:
+            self._session.cert = (_cert, _key)
+        elif _cert:
+            self._session.cert = _cert
+
+    def set_rate_limit(self, rate_limit):
+        global rate_limits
+        rate_limits = rate_limit
+
+
+    def get_rate_limits(self):
+        return rate_limits
+
+    def request(self, method, url, data=None, idempotency_key=None, oauth_request=False, without_client_id=False,
+                is_v3=False, **params):
+        return self.custom_request(method, url, data, idempotency_key, oauth_request, True,
+                                   without_client_id, is_v3, **params)
+
+    def multipart_request(self, method, url, file, file_name, idempotency_key=None, oauth_request=False, is_v3=False):
+        return self.custom_multipart_request(method, url, file, file_name, idempotency_key, oauth_request, is_v3)
+
+    def custom_request(self, method, url, data=None, idempotency_key=None, oauth_request=False,
+                       is_mangopay_request=False, without_client_id=False, is_v3=False, **params):
+        params = params or {}
+
+        headers = {}
+
+        if is_mangopay_request:
+            headers['User-Agent'] = 'Mangopay-SDK/' + str(
+                mangopay.package_version) + ' (Python/' + platform.python_version() + ')'
+            if oauth_request:
+                headers['Authorization'] = self.auth_manager.basic_token()
+                headers['Content-Type'] = 'application/x-www-form-urlencoded'
+            else:
+                headers['Authorization'] = self.auth_manager.get_token()
+                headers['Content-Type'] = 'application/json'
+
+            if idempotency_key:
+                headers['Idempotency-Key'] = idempotency_key
+
+            if self.uk_header_flag:
+                logger.warning('uk_header_flag is deprecated and will be removed in future versions')
+                headers['x-tenant-id'] = 'uk'
+        else:
+            if "data_XXX" in params:
+                params[str("data")] = params[str("data_XXX")]
+                params.__delitem__(str("data_XXX"))
+                headers['Content-Type'] = 'application/x-www-form-urlencoded'
+
+        # truncated_data = None
+
+        encoded_params = urlrequest.urlencode(params)
+
+        if is_mangopay_request:
+            if oauth_request or without_client_id:
+                url = self.api_url + url
+            else:
+                url = self._absolute_url(url, encoded_params)
+        else:
+            url = '%s?%s' % (url, encoded_params)
+
+        if is_v3:
+            url = url.replace('v2.01', 'V3.0')
+
+        if data or data == {}:
+            # truncated_data = truncatechars(copy.copy(data))
+
+            data = json.dumps(data, default=lambda x: x.to_api_json())
+
+        logger.debug('DATA[IN -> %s]\n\t- headers: %s\n\t- content: %s', url, headers, data)
+
+        ts = time.time()
+
+        # signal:
+        request_started.send(url=url, data=data, headers=headers, method=method)
+
+        try:
+            result = self._session.request(method, url,
+                                           data=data,
+                                           headers=headers,
+                                           timeout=self.timeout,
+                                           proxies=self.proxies)
+        except ConnectionError as e:
+            msg = '{}'.format(e)
+
+            if msg:
+                msg = '%s: %s' % (type(e).__name__, msg)
+            else:
+                msg = type(e).__name__
+
+            reraise_as(APIError(msg))
+
+        except Timeout as e:
+            msg = '{}'.format(e)
+
+            if msg:
+                msg = '%s: %s' % (type(e).__name__, msg)
+            else:
+                msg = type(e).__name__
+
+            reraise_as(APIError(msg))
+        laps = time.time() - ts
+
+        # signal:
+        request_finished.send(url=url,
+                              data=data,
+                              headers=headers,
+                              method=method,
+                              result=result,
+                              laps=laps)
+
+        logger.debug('DATA[OUT -> %s][%2.3f seconds]\n\t- status_code: %s\n\t- headers: %s\n\t- content: %s',
+            url,
+            laps,
+            result.status_code,
+            result.headers,
+            result.text if hasattr(result, 'text') else result.content
+        )
+
+        self.read_response_headers(result.headers)
+
+        if result.status_code not in (requests.codes.ok, requests.codes.not_found,
+                                      requests.codes.created, requests.codes.accepted,
+                                      requests.codes.no_content):
+            self._create_apierror(result, url=url, data=data, method=method)
+        elif result.status_code == requests.codes.no_content or (result.status_code == requests.codes.ok and result.content == b''):
+            return result, None
+        else:
+            if result.content:
+                try:
+                    content = result.content
+
+                    if six.PY3:
+                        content = content.decode('utf-8')
+
+                    return result, json.loads(content)
+                except ValueError:
+                    if result.content.startswith(b'data='):
+                        return result.content
+                    self._create_decodeerror(result, url=url)
+            else:
+                self._create_decodeerror(result, url=url)
+
+    def custom_multipart_request(self, method, url, file, file_name, idempotency_key=None, oauth_request=False, is_v3=False):
+        if not isinstance(file, bytes):
+            raise TypeError("The 'file' parameter must be of type 'bytes'.")
+
+        headers = {'User-Agent': 'Mangopay-SDK/' + str(
+            mangopay.package_version) + ' (Python/' + platform.python_version() + ')'}
+
+        if oauth_request:
+            headers['Authorization'] = self.auth_manager.basic_token()
+        else:
+            headers['Authorization'] = self.auth_manager.get_token()
+
+        if idempotency_key:
+            headers['Idempotency-Key'] = idempotency_key
+
+        if self.uk_header_flag:
+            logger.warning('uk_header_flag is deprecated and will be removed in future versions')
+            headers['x-tenant-id'] = 'uk'
+
+        if oauth_request:
+            url = self.api_url + url
+        else:
+            url = self._absolute_url(url, '')
+
+        if is_v3:
+            url = url.replace('v2.01', 'V3.0')
+
+        files = {'file': (file_name, file)}
+
+        logger.debug('DATA[IN -> %s]\n\t- headers: %s\n\t- file: %s', url, headers, 'provided' if file else 'none')
+        ts = time.time()
+
+        request_started.send(url=url, data=None, headers=headers, method=method)
+
+        try:
+            result = self._session.request(method, url,
+                                           files=files,
+                                           headers=headers,
+                                           timeout=self.timeout,
+                                           proxies=self.proxies)
+        except ConnectionError as e:
+            msg = f'{type(e).__name__}: {e}' if str(e) else type(e).__name__
+            reraise_as(APIError(msg))
+
+        except Timeout as e:
+            msg = f'{type(e).__name__}: {e}' if str(e) else type(e).__name__
+            reraise_as(APIError(msg))
+
+        laps = time.time() - ts
+
+        request_finished.send(url=url,
+                              data=None,
+                              headers=headers,
+                              method=method,
+                              result=result,
+                              laps=laps)
+
+        logger.debug('DATA[OUT -> %s][%2.3f seconds]\n\t- status_code: %s\n\t- headers: %s\n\t- content: %s',
+                     url,
+                     laps,
+                     result.status_code,
+                     result.headers,
+                     result.text if hasattr(result, 'text') else result.content
+                     )
+
+        self.read_response_headers(result.headers)
+
+        if result.status_code not in (requests.codes.ok, requests.codes.not_found,
+                                      requests.codes.created, requests.codes.accepted,
+                                      requests.codes.no_content):
+            self._create_apierror(result, url=url, data=None, method=method)
+        elif result.status_code == requests.codes.no_content or (
+                result.status_code == requests.codes.ok and result.content == b''):
+            return result, None
+        else:
+            if result.content:
+                try:
+                    content = result.content
+                    if six.PY3:
+                        content = content.decode('utf-8')
+                    return result, json.loads(content)
+                except ValueError:
+                    if result.content.startswith(b'data='):
+                        return result.content
+                    self._create_decodeerror(result, url=url)
+            else:
+                self._create_decodeerror(result, url=url)
+
+    def read_response_headers(self, headers):
+        rate_limit_reset = headers.get('x-ratelimit-reset')
+        rate_limit_remaining = headers.get('x-ratelimit-remaining')
+        rate_limit_made = headers.get('x-ratelimit')
+
+        if rate_limit_reset is not None and rate_limit_remaining is not None and rate_limit_made is not None:
+            rate_limit_reset = rate_limit_reset.split(',')
+            rate_limit_remaining = rate_limit_remaining.split(',')
+            rate_limit_made = rate_limit_made.split(',')
+
+            if len(rate_limit_reset) == len(rate_limit_remaining) and len(rate_limit_reset) == len(rate_limit_made):
+                current_time = int(time.time())
+                updated_rate_limits = []
+
+                for i, rlr in enumerate(rate_limit_reset):
+                    rate_limit = RateLimit()
+                    number_of_minutes = (int(rate_limit_reset[i].strip()) - current_time) / 60
+
+                    if number_of_minutes <= 15:
+                        rate_limit.interval_minutes = 15
+                    elif number_of_minutes <= 30:
+                        rate_limit.interval_minutes = 30
+                    elif number_of_minutes <= 60:
+                        rate_limit.interval_minutes = 60
+                    elif number_of_minutes <= 60 * 24:
+                        rate_limit.interval_minutes = 60 * 24
+
+                    rate_limit.reset_time_millis = int(rate_limit_reset[i].strip())
+                    rate_limit.calls_remaining = int(rate_limit_remaining[i].strip())
+                    rate_limit.calls_made = int(rate_limit_made[i].strip())
+                    updated_rate_limits.append(rate_limit)
+
+                if len(updated_rate_limits) > 0:
+                    self.set_rate_limit(updated_rate_limits)
+
+            else:
+                logger.debug("Could not set rate limits: headers length should be the same")
+        else:
+            logger.debug("Could not set rate limits: missing headers")
+
+    def _absolute_url(self, url, encoded_params):
+        pattern = '%s%s%s'
+
+        if encoded_params:
+            pattern = '%s%s?%s'
+
+        return pattern % (self.api_url, self._construct_api_url(url), encoded_params)
+
+    def _construct_api_url(self, relative_url):
+        return '%s%s' % (self.client_id, relative_url)
+
+    def _create_apierror(self, result, url=None, data=None, method=None):
+        text = result.text if hasattr(result, 'text') else result.content
+
+        status_code = result.status_code
+
+        headers = result.headers
+
+        logger.error('API ERROR: status_code: %s | url: %s | method: %s | data: %r | headers: %s | content: %s',
+            status_code,
+            url,
+            method,
+            data,
+            headers,
+            text,
+        )
+
+        request_error.send(url=url, status_code=status_code, headers=headers)
+
+        try:
+            content = result.json()
+        except ValueError:
+            content = None
+
+        raise APIError(text, code=status_code, content=content, headers=headers)
+
+    def _create_decodeerror(self, result, url=None):
+
+        text = result.text if hasattr(result, 'text') else result.content
+
+        status_code = result.status_code
+
+        headers = result.headers
+
+        logger.error('DECODE ERROR: status_code: %s | headers: %s | content: %s',
+            status_code,
+            headers,
+            text,
+        )
+
+        request_error.send(url=url, status_code=status_code, headers=headers)
+
+        try:
+            content = result.json()
+        except ValueError:
+            content = None
+
+        raise DecodeError(text,
+                          code=status_code,
+                          headers=headers,
+                          content=content)

mangopay/auth.py

@@ -0,0 +1,130 @@
+import base64
+import hashlib
+import json
+import os
+import stat
+import tempfile
+import time
+
+import six
+
+import mangopay
+from mangopay.exceptions import AuthenticationError
+
+
+class StorageStrategyBase(object):
+
+    def get(self, env_key):
+        pass
+
+    def store(self, token, env_key):
+        pass
+
+
+class StaticStorageStrategy(StorageStrategyBase):
+
+    _dict = dict()
+
+    def get(self, env_key):
+        return StaticStorageStrategy._dict[env_key]
+
+    def store(self, token, env_key):
+        StaticStorageStrategy._dict[env_key] = token
+
+
+class FileStorageStrategy(StorageStrategyBase):
+
+    def __init__(self):
+        if mangopay.temp_dir is None:
+            mangopay.temp_dir = tempfile.gettempdir()
+
+    def get(self, env_key):
+        cache_path = os.path.join(mangopay.temp_dir, "cached-data." + env_key + ".py")
+
+        if not os.path.exists(cache_path):
+            return None
+
+        with open(cache_path, 'rb') as f:
+            serialized_obj = f.read().decode('UTF-8')
+            try:
+                cached = json.loads(serialized_obj[1:])
+            except:
+                cached = None
+
+        return cached
+
+    def store(self, token, env_key):
+        cache_path = os.path.join(mangopay.temp_dir, "cached-data." + env_key + ".py")
+        if token is None:
+            return
+
+        with open(cache_path, 'w') as f:
+            os.chmod(cache_path, stat.S_IRUSR | stat.S_IWUSR)
+            serialized_obj = "#" + json.dumps(token)
+            f.write(serialized_obj)
+
+
+class AuthorizationTokenManager(object):
+
+    def __init__(self, handler, storage_strategy):
+        self._handler = handler
+        self.authorization = ApiAuthorization(handler)
+        if storage_strategy:
+            self.storage_strategy = storage_strategy
+        else:
+            self.storage_strategy = StaticStorageStrategy()
+
+    def basic_token(self):
+        return self.authorization.basic_token()
+
+    def get_token(self):
+        try:
+            token = self.storage_strategy.get(self.get_evn_key())
+        except KeyError:
+            token = None
+
+        if not token or not token['timestamp'] or token['timestamp'] <= time.time():
+            auth_result = self.authorization.oauth_token()
+            if auth_result[0].status_code == 200:
+                token = auth_result[1]
+            else:
+                return None
+            token['timestamp'] = time.time() + (int(token['expires_in']) - 30)
+            self.set_token(token)
+
+        return token['token_type'] + ' ' + token['access_token']
+
+    def set_token(self, token):
+        self.storage_strategy.store(token, self.get_evn_key())
+
+    def get_evn_key(self):
+        return hashlib.md5((self._handler.client_id + self._handler.api_url +
+                            self._handler.apikey).encode('utf-8')).hexdigest()
+
+
+class ApiAuthorization(object):
+
+    def __init__(self, handler):
+        self._handler = handler
+
+    def oauth_token(self):
+        result = self._handler.request(method='POST',
+                                       url='oauth/token',
+                                       data={'grant_type': 'client_credentials'},
+                                       oauth_request=True)
+        return result
+
+    def basic_token(self):
+        if self._handler.client_id is None or self._handler.apikey is None:
+            raise AuthenticationError(
+                'Authentication failed. (Please set your Mangopay API username '
+                'and password using "mangopay.client_id = CLIENT_ID" '
+                'and "mangopay.apikey = APIKEY").')
+
+        credentials = '%s:%s' % (self._handler.client_id, self._handler.apikey)
+        credentials = base64.b64encode(credentials.encode('ascii'))
+
+        if six.PY3:
+            credentials = credentials.decode('utf-8')
+
+        return 'Basic %s' % credentials