connect-sdk-python3 3.47.0__zip → 4.0.1__zip

connect-sdk-python3-3.47.0/ingenico/connect/sdk/declined_refund_exception.py

@@ -1,37 +0,0 @@
-from .declined_transaction_exception import DeclinedTransactionException
-
-
-class DeclinedRefundException(DeclinedTransactionException):
-    """
-    Represents an error response from a refund call.
-    """
-
-    def __init__(self, status_code, response_body, errors):
-        if errors is not None:
-            super(DeclinedRefundException, self).__init__(status_code, response_body, errors.error_id, errors.errors,
-                                                          DeclinedRefundException.__create_message(errors))
-        else:
-            super(DeclinedRefundException, self).__init__(status_code, response_body, None, None,
-                                                          DeclinedRefundException.__create_message(errors))
-        self.__errors = errors
-
-    @staticmethod
-    def __create_message(errors):
-        if errors is not None:
-            refund = errors.refund_result
-        else:
-            refund = None
-        if refund is not None:
-            return "declined refund '" + refund.id + "' with status '" + refund.status + "'"
-        else:
-            return "the Ingenico ePayments platform returned a declined refund response"
-
-    @property
-    def refund_result(self):
-        """
-        :return: The result of creating a refund if available, otherwise None.
-        """
-        if self.__errors is None:
-            return None
-        else:
-            return self.__errors.refund_result

connect-sdk-python3-3.47.0/ingenico/connect/sdk/declined_transaction_exception.py

@@ -1,13 +0,0 @@
-from .api_exception import ApiException
-
-
-class DeclinedTransactionException(ApiException):
-    """
-    Represents an error response from a create payment, payout or refund call.
-    """
-
-    def __init__(self, status_code, response_body, error_id, errors, message=False):
-        if message is False:
-            super(DeclinedTransactionException, self).__init__(status_code, response_body, error_id, errors)
-        else:
-            super(DeclinedTransactionException, self).__init__(status_code, response_body, error_id, errors, message)

connect-sdk-python3-3.47.0/ingenico/connect/sdk/defaultimpl/authorization_type.py

@@ -1,13 +0,0 @@
-class AuthorizationType:
-    def __init__(self):
-        pass
-
-    V1HMAC = "v1HMAC"
-    AUTHORIZATION_TYPES = [V1HMAC]
-
-    @staticmethod
-    def get_authorization(name):
-        if name in AuthorizationType.AUTHORIZATION_TYPES:
-            return name
-        else:
-            raise ValueError("Authorization '{}' not found".format(name))

connect-sdk-python3-3.47.0/ingenico/connect/sdk/defaultimpl/default_authenticator.py

@@ -1,108 +0,0 @@
-import hashlib
-import hmac
-from base64 import b64encode
-from operator import attrgetter
-from re import sub
-
-from ingenico.connect.sdk.authenticator import Authenticator
-from ingenico.connect.sdk.request_header import RequestHeader
-
-
-class DefaultAuthenticator(Authenticator):
-    """
-    Default Authenticator implementation.
-    """
-
-    def __init__(self, authorization_type, api_id_key, secret_api_key):
-        """
-        :param authorization_type: Based on this value both the Ingenico ePayments
-         platform and the merchant know which security implementation is used.
-         A version number is used for backward compatibility in the future.
-        :param api_id_key: An identifier for the secret API key. The api_key_id
-         can be retrieved from the Configuration Center. This identifier is
-         visible in the HTTP request and is also used to identify the correct
-         account.
-        :param secret_api_key: A shared secret. The shared secret can be
-         retrieved from the Configuration Center. An api_key_id and
-         secret_api_key always go hand-in-hand, the difference is that
-         secret_api_key is never visible in the HTTP request. This secret is
-         used as input for the HMAC algorithm.
-        """
-        Authenticator.__init__(self)
-        if authorization_type is None:
-            raise ValueError("authorization_type is required")
-        if secret_api_key is None or not secret_api_key.strip():
-            raise ValueError("secret_api_key is required")
-        if api_id_key is None or not api_id_key.strip():
-            raise ValueError("api_id_key is required")
-        self.__authorization_type = authorization_type
-        self.__api_id_key = api_id_key
-        self.__secret_api_key = secret_api_key
-
-    def create_simple_authentication_signature(self, http_method, resource_uri, http_headers):
-        """Returns a v1HMAC authentication signature header"""
-        if http_method is None or not http_method.strip():
-            raise ValueError("http_method is required")
-        if resource_uri is None:
-            raise ValueError("resource_uri is required")
-        data_to_sign = self.to_data_to_sign(http_method, resource_uri, http_headers)
-        return "GCS " + self.__authorization_type + ":" + self.__api_id_key + ":" + self.create_authentication_signature(data_to_sign)
-
-    def to_data_to_sign(self, http_method, resource_uri, http_headers):
-        content_type = None
-        date = None
-        canonicalized_headers = ""
-        canonicalized_resource = self.__to_canonicalized_resource(resource_uri)
-        xgcs_http_headers = []
-        if http_headers is not None:
-            for http_header in http_headers:
-                if "Content-Type".lower() == http_header.name.lower():
-                    content_type = http_header.value
-                elif "Date".lower() == http_header.name.lower():
-                    date = http_header.value
-                else:
-                    name = self.__to_canonicalize_header_name(http_header.name)
-                    if name.startswith("x-gcs"):
-                        value = self.to_canonicalize_header_value(http_header.value)
-                        xgcs_http_header = RequestHeader(name, value)
-                        xgcs_http_headers.append(xgcs_http_header)
-        xgcs_http_headers.sort(key=attrgetter('name'))
-        for xgcs_http_header in xgcs_http_headers:
-            canonicalized_headers += xgcs_http_header.name + ":" + xgcs_http_header.value + "\n"
-        string = http_method.upper() + "\n"
-        if content_type is not None:
-            string += content_type + "\n"
-        else:
-            string += "\n"
-        string += date + "\n"
-        string += str(canonicalized_headers)
-        string += canonicalized_resource + "\n"
-        return str(string)
-
-    @staticmethod
-    def __to_canonicalized_resource(resource_uri):
-        """
-        Returns the encoded URI path without the HTTP method and including all decoded query parameters.
-        """
-        string = ""
-        string += resource_uri.path
-        if resource_uri.query:
-            string += "?" + resource_uri.query
-        return str(string)
-
-    @staticmethod
-    def __to_canonicalize_header_name(original_name):
-        if original_name is None:
-            return None
-        else:
-            return original_name.lower()
-
-    def to_canonicalize_header_value(self, original_value):
-        # For now V1HMAC is the only supported AuthorizationType so always use the same logic.
-        if original_value is None:
-            return ""
-        return sub(r"\r?\n(?:(?![\r\n])\s)*", " ", original_value).strip()
-
-    def create_authentication_signature(self, data_to_sign):
-        sig = hmac.new(self.__secret_api_key.encode("utf-8"), data_to_sign.encode("utf-8"), hashlib.sha256)
-        return b64encode(sig.digest()).decode("utf-8").rstrip('\n')

connect-sdk-python3-3.47.0/ingenico/connect/sdk/defaultimpl/default_connection.py

@@ -1,295 +0,0 @@
-import math
-import uuid
-from datetime import datetime
-from urllib.parse import urlparse
-
-import requests
-from requests.adapters import HTTPAdapter
-from requests.exceptions import RequestException, Timeout
-from requests_toolbelt import MultipartEncoder
-
-from ingenico.connect.sdk.communication_exception import CommunicationException
-from ingenico.connect.sdk.endpoint_configuration import EndpointConfiguration
-from ingenico.connect.sdk.log.body_obfuscator import BodyObfuscator
-from ingenico.connect.sdk.log.header_obfuscator import HeaderObfuscator
-from ingenico.connect.sdk.log.obfuscation_capable import ObfuscationCapable
-from ingenico.connect.sdk.log.request_log_message import RequestLogMessage
-from ingenico.connect.sdk.log.response_log_message import ResponseLogMessage
-from ingenico.connect.sdk.pooled_connection import PooledConnection
-from ingenico.connect.sdk.multipart_form_data_object import MultipartFormDataObject
-from ingenico.connect.sdk.response_header import get_header_value
-
-CHARSET = "UTF-8"
-
-
-class DefaultConnection(PooledConnection, ObfuscationCapable):
-    """
-    Provides an HTTP request interface, thread-safe
-
-    :param connect_timeout: timeout in seconds before a pending connection is dropped
-    :param socket_timeout: timeout in seconds before dropping an established connection.
-     This is the time the server is allowed for a response
-    :param max_connections: the maximum number of connections in the connection pool
-    :param proxy_configuration: ProxyConfiguration object that contains data about proxy settings if present.
-     It should be writeable as string and have a scheme attribute.
-
-    Use the methods get, delete, post and put to perform the corresponding HTTP request.
-    Alternatively you can use request with the request method as the first parameter.
-
-    URI, headers and body should be given on a per-request basis.
-    """
-
-    def __init__(self, connect_timeout, socket_timeout,
-                 max_connections=EndpointConfiguration.DEFAULT_MAX_CONNECTIONS,
-                 proxy_configuration=None):
-        self.logger = None
-        self.__requests_session = requests.session()
-        self.__requests_session.mount("http://", HTTPAdapter(pool_maxsize=max_connections,
-                                                             pool_connections=1))
-        self.__requests_session.mount("https://", HTTPAdapter(pool_maxsize=max_connections,
-                                                              pool_connections=1))
-        # request timeouts are in seconds
-        self.__connect_timeout = connect_timeout if connect_timeout >= 0 else None
-        self.__socket_timeout = socket_timeout if socket_timeout >= 0 else None
-        if proxy_configuration:
-            proxy = {
-                "http": str(proxy_configuration),
-                "https": str(proxy_configuration)
-            }
-            self.__requests_session.proxies = proxy
-
-        self.__body_obfuscator = BodyObfuscator.default_body_obfuscator()
-        self.__header_obfuscator = HeaderObfuscator.default_header_obfuscator()
-
-    @property
-    def connect_timeout(self):
-        """Connection timeout in seconds"""
-        return self.__connect_timeout
-
-    @property
-    def socket_timeout(self):
-        """Socket timeout in seconds"""
-        return self.__socket_timeout
-
-    def get(self, url, request_headers):
-        """Perform a request to the server given by url
-
-        :param url: the url to the server, given as a parsed url
-        :param request_headers: a sequence containing RequestHeader objects representing the request headers
-        """
-        return self._request('get', url, request_headers)
-
-    def delete(self, url, request_headers):
-        """Perform a request to the server given by url
-
-        :param url: the url to the server, given as a parsed url
-        :param request_headers: a sequence containing RequestHeader objects representing the request headers
-        """
-        return self._request('delete', url, request_headers)
-
-    def post(self, url, request_headers, body):
-        """Perform a request to the server given by url
-
-        :param url: the url to the server, given as a parsed url
-        :param request_headers: a sequence containing RequestHeader objects representing the request headers
-        :param body: the request body
-        """
-        if isinstance(body, MultipartFormDataObject):
-            body = self.__to_multipart_encoder(body)
-        return self._request('post', url, request_headers, body)
-
-    def put(self, url, request_headers, body):
-        """Perform a request to the server given by url
-
-        :param url: the url to the server, given as a parsed url
-        :param request_headers: a sequence containing RequestHeader objects representing the request headers
-        :param body: the request body
-        """
-        if isinstance(body, MultipartFormDataObject):
-            body = self.__to_multipart_encoder(body)
-        return self._request('put', url, request_headers, body)
-
-    @staticmethod
-    def __to_multipart_encoder(multipart):
-        fields = {}
-        for name, value in multipart.values.items():
-            fields[name] = value
-        for name, uploadable_file in multipart.files.items():
-            fields[name] = (uploadable_file.file_name, uploadable_file.content, uploadable_file.content_type)
-        encoder = MultipartEncoder(fields=fields,
-                                   boundary=multipart.boundary)
-        if encoder.content_type != multipart.content_type:
-            raise ValueError("MultipartEncoder did not create the expected content type")
-        return encoder
-
-    class _ToResult(object):
-        def __call__(self, func):
-            def _wrapper(*args, **kwargs):
-                result = func(*args, **kwargs)
-                header = next(result)
-                return header + (result,)
-            return _wrapper
-
-    @_ToResult()
-    def _request(self, method, url, headers, body=None):
-        """
-        Perform a request to the server given by url
-
-        :param url: the url to the server, given as a parsed url
-        :param headers: a sequence containing RequestHeader objects representing the request headers
-        :param body: the request body
-        """
-        headers = {} if not headers else headers
-        if not isinstance(url, str):
-            url = url.geturl()
-
-        # convert the sequence of RequestParam objects to a dictionary of key:value pairs if necessary
-        if headers and not isinstance(headers, dict):
-            headers = {param.name: param.value for param in headers}
-
-        # send request with all parameters not declared in session and with callback for logging response
-        request = requests.Request(method, url,
-                                   headers=headers,
-                                   data=body,
-                                   hooks={'response': self._cb_log_response})
-        prepped_request = self.__requests_session.prepare_request(request)
-        # add timestamp to request for later reference
-        prepped_request.timestamp = datetime.now()
-        _id = str(uuid.uuid4())
-        # store random id in request so it can be matched with its response in logging
-        prepped_request.id = _id
-        self._log_request(prepped_request)
-        try:
-            timeout_ = (self.__connect_timeout, self.__socket_timeout)
-            requests_response = self.__requests_session.send(prepped_request,
-                                                             timeout=timeout_,
-                                                             stream=True)
-            try:
-                iterable = requests_response.iter_content(chunk_size=1024)
-                yield requests_response.status_code, requests_response.headers
-                for chunk in iterable:
-                    yield chunk
-            finally:
-                requests_response.close()
-
-        except Timeout as timeout:
-            self._log_error(prepped_request.id, timeout, prepped_request.timestamp)
-            raise CommunicationException(timeout)
-        except RequestException as exception:
-            self._log_error(prepped_request.id, exception, prepped_request.timestamp)
-            raise CommunicationException(exception)
-        except Exception as exception:
-            self._log_error(prepped_request.id, exception, prepped_request.timestamp)
-            raise
-
-    def _log_request(self, request):
-        """
-        Log parameter request if logging is enabled at the moment of logging.
-        Also adds a timestamp to the request for response logging
-        """
-        logger = self.logger
-        if logger is None:
-            return
-        method = request.method
-        url = urlparse(request.url)
-        if url.query:
-            local_path = url.path + "?" + url.query
-        else:
-            local_path = url.path
-        try:
-            message = RequestLogMessage(request_id=request.id,
-                                        method=method,
-                                        uri=local_path,
-                                        body_obfuscator=self.__body_obfuscator,
-                                        header_obfuscator=self.__header_obfuscator)
-            for name in request.headers:
-                message.add_header(name, request.headers[name])
-            body = request.body
-            if body:
-                content = request.headers['Content-Type']
-                if content != "application/json":
-                    message.set_body(body, content, CHARSET)
-                else:
-                    message.set_body(body, content)
-            logger.log_request(message)
-        except Exception as exception:
-            logger.log("An error occurred trying to log request '{}'".format(request.id), exception)
-
-    def _cb_log_response(self, response, **kwargs):
-        """Log parameter response if logging is enabled at the moment of logging"""
-        logger = self.logger
-        if logger is None:
-            return
-        request = response.request
-        _id = request.id
-        duration = math.ceil((datetime.now() - request.timestamp).total_seconds() * 1000)
-        status_code = response.status_code
-        try:
-            message = ResponseLogMessage(request_id=_id,
-                                         status_code=status_code,
-                                         duration=duration,
-                                         body_obfuscator=self.__body_obfuscator,
-                                         header_obfuscator=self.__header_obfuscator)
-            for name in response.headers:
-                message.add_header(name, response.headers[name])
-            if self.__is_binary(response.headers):
-                body = "<binary content>"
-            else:
-                # The response is always encoded UTF8
-                # When this is not specified anywhere, the response body will be encoded in the wrong way
-                response.encoding = 'utf8'
-                body = response.text
-            if body:
-                content = response.headers['Content-Type']
-                message.set_body(body, content)
-            logger.log_response(message)
-        except Exception as exception:
-            logger.log("An error occurred trying to log response '{}'".format(_id), exception)
-
-    def _log_error(self, request_id, error, start_time):
-        """Log communication errors when logging is enabled"""
-        logger = self.logger
-        if logger:
-            duration = math.ceil((datetime.now() - start_time).total_seconds() * 1000)
-            logger.log("Error occurred for outgoing request (requestId='{}', {} s)".format(request_id, duration), error)
-
-    @staticmethod
-    def __is_binary(headers):
-        content_type = get_header_value(headers, "Content-Type")
-        if content_type is None:
-            return False
-        content_type = content_type.lower()
-        return not (content_type.startswith("text/") or "json" in content_type or "xml" in content_type)
-
-    def set_body_obfuscator(self, body_obfuscator):
-        self.__body_obfuscator = body_obfuscator
-
-    def set_header_obfuscator(self, header_obfuscator):
-        self.__header_obfuscator = header_obfuscator
-
-    def enable_logging(self, communicator_logger):
-        self.logger = communicator_logger
-
-    def disable_logging(self):
-        self.logger = None
-
-    def close_idle_connections(self, idle_time):
-        """
-        :param idle_time: a datetime.timedelta object indicating the idle time
-        """
-        pass
-
-    def close_expired_connections(self):
-        pass
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
-
-    def close(self):
-        """
-        Explicitly closes the connection
-        """
-        self.__requests_session.close()

connect-sdk-python3-3.47.0/ingenico/connect/sdk/defaultimpl/default_marshaller.py

@@ -1,58 +0,0 @@
-from json import dumps, loads
-
-from ingenico.connect.sdk.data_object import DataObject
-from ingenico.connect.sdk.marshaller import Marshaller
-from ingenico.connect.sdk.marshaller_syntax_exception import MarshallerSyntaxException
-
-
-class DefaultMarshaller(Marshaller):
-    """
-    Marshaller implementation based on json.
-    """
-
-    @staticmethod
-    def INSTANCE():
-        return _DEFAULT_MARSHALLER_INSTANCE
-
-    def marshal(self, request_object):
-        if isinstance(request_object, DataObject):
-            dictionary = request_object.to_dictionary()
-            return dumps(dictionary,
-                         default=lambda o: o.to_dictionary(),
-                         indent=4)
-        else:
-            return dumps(request_object,
-                         default=lambda o: o.__dict__,
-                         indent=4)
-
-    def unmarshal(self, response_json, type_class):
-        if not response_json:
-            return None
-        if issubclass(type_class, DataObject):
-            try:
-                return type_class().from_dictionary(loads(response_json))
-            except ValueError as e:
-                raise MarshallerSyntaxException(e)
-
-        class Object(object):
-            pass
-
-        def convert_to_object(d):
-            try:
-                d = dict(d)
-            except (TypeError, ValueError):
-                return d
-            o = Object()
-            for key, value in d.items():
-                o.__dict__[key] = convert_to_object(value)
-            return o
-
-        try:
-            dictionary = loads(response_json)
-            converted_object = convert_to_object(dictionary)
-            return converted_object
-        except ValueError as e:
-            raise MarshallerSyntaxException(e)
-
-
-_DEFAULT_MARSHALLER_INSTANCE = DefaultMarshaller()

connect-sdk-python3-3.47.0/ingenico/connect/sdk/domain/capture/__init__.py

@@ -1,4 +0,0 @@
-#
-# This file was auto-generated from the API references found at
-# https://epayments-api.developer-ingenico.com
-#

connect-sdk-python3-3.47.0/ingenico/connect/sdk/domain/capture/capture_response.py

@@ -1,17 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://epayments-api.developer-ingenico.com/
-#
-from ingenico.connect.sdk.domain.capture.definitions.capture import Capture
-
-
-class CaptureResponse(Capture):
-
-    def to_dictionary(self):
-        dictionary = super(CaptureResponse, self).to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(CaptureResponse, self).from_dictionary(dictionary)
-        return self

connect-sdk-python3-3.47.0/ingenico/connect/sdk/domain/capture/captures_response.py

@@ -1,45 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://epayments-api.developer-ingenico.com/
-#
-from ingenico.connect.sdk.data_object import DataObject
-from ingenico.connect.sdk.domain.capture.definitions.capture import Capture
-
-
-class CapturesResponse(DataObject):
-
-    __captures = None
-
-    @property
-    def captures(self):
-        """
-        | The list of all captures performed on the requested payment.
-        
-        Type: list[:class:`ingenico.connect.sdk.domain.capture.definitions.capture.Capture`]
-        """
-        return self.__captures
-
-    @captures.setter
-    def captures(self, value):
-        self.__captures = value
-
-    def to_dictionary(self):
-        dictionary = super(CapturesResponse, self).to_dictionary()
-        if self.captures is not None:
-            dictionary['captures'] = []
-            for element in self.captures:
-                if element is not None:
-                    dictionary['captures'].append(element.to_dictionary())
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(CapturesResponse, self).from_dictionary(dictionary)
-        if 'captures' in dictionary:
-            if not isinstance(dictionary['captures'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['captures']))
-            self.captures = []
-            for element in dictionary['captures']:
-                value = Capture()
-                self.captures.append(value.from_dictionary(element))
-        return self

connect-sdk-python3-3.47.0/ingenico/connect/sdk/domain/capture/definitions/__init__.py

@@ -1,4 +0,0 @@
-#
-# This file was auto-generated from the API references found at
-# https://epayments-api.developer-ingenico.com
-#