connect-sdk-python3 3.46.0__zip → 4.0.0__zip

connect-sdk-python3-3.46.0/ingenico/connect/sdk/merchant/tokens/tokens_client.py

@@ -1,200 +0,0 @@
-#
-# This class was auto-generated from the API references found at
-# https://epayments-api.developer-ingenico.com/
-#
-from ingenico.connect.sdk.api_resource import ApiResource
-from ingenico.connect.sdk.response_exception import ResponseException
-from ingenico.connect.sdk.domain.errors.error_response import ErrorResponse
-from ingenico.connect.sdk.domain.token.create_token_response import CreateTokenResponse
-from ingenico.connect.sdk.domain.token.token_response import TokenResponse
-
-
-class TokensClient(ApiResource):
-    """
-    Tokens client. Thread-safe.
-    """
-
-    def __init__(self, parent, path_context):
-        """
-        :param parent:       :class:`ingenico.connect.sdk.api_resource.ApiResource`
-        :param path_context: dict[str, str]
-        """
-        super(TokensClient, self).__init__(parent, path_context)
-
-    def create(self, body, context=None):
-        """
-        Resource /{merchantId}/tokens - Create token
-        
-        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/tokens/create.html
-
-        :param body:     :class:`ingenico.connect.sdk.domain.token.create_token_request.CreateTokenRequest`
-        :param context:  :class:`ingenico.connect.sdk.call_context.CallContext`
-        :return: :class:`ingenico.connect.sdk.domain.token.create_token_response.CreateTokenResponse`
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: GlobalCollectException if something went wrong at the Ingenico ePayments platform,
-                   the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Ingenico ePayments platform returned any other error
-        """
-        uri = self._instantiate_uri("/v1/{merchantId}/tokens", None)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    CreateTokenResponse,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def get(self, token_id, context=None):
-        """
-        Resource /{merchantId}/tokens/{tokenId} - Get token
-        
-        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/tokens/get.html
-
-        :param token_id:  str
-        :param context:   :class:`ingenico.connect.sdk.call_context.CallContext`
-        :return: :class:`ingenico.connect.sdk.domain.token.token_response.TokenResponse`
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: GlobalCollectException if something went wrong at the Ingenico ePayments platform,
-                   the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Ingenico ePayments platform returned any other error
-        """
-        path_context = {
-            "tokenId": token_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/tokens/{tokenId}", path_context)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    None,
-                    TokenResponse,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def update(self, token_id, body, context=None):
-        """
-        Resource /{merchantId}/tokens/{tokenId} - Update token
-        
-        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/tokens/update.html
-
-        :param token_id:  str
-        :param body:      :class:`ingenico.connect.sdk.domain.token.update_token_request.UpdateTokenRequest`
-        :param context:   :class:`ingenico.connect.sdk.call_context.CallContext`
-        :return: None
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: GlobalCollectException if something went wrong at the Ingenico ePayments platform,
-                   the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Ingenico ePayments platform returned any other error
-        """
-        path_context = {
-            "tokenId": token_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/tokens/{tokenId}", path_context)
-        try:
-            return self._communicator.put(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    None,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def delete(self, token_id, query, context=None):
-        """
-        Resource /{merchantId}/tokens/{tokenId} - Delete token
-        
-        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/tokens/delete.html
-
-        :param token_id:  str
-        :param query:     :class:`ingenico.connect.sdk.merchant.tokens.delete_token_params.DeleteTokenParams`
-        :param context:   :class:`ingenico.connect.sdk.call_context.CallContext`
-        :return: None
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: GlobalCollectException if something went wrong at the Ingenico ePayments platform,
-                   the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Ingenico ePayments platform returned any other error
-        """
-        path_context = {
-            "tokenId": token_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/tokens/{tokenId}", path_context)
-        try:
-            return self._communicator.delete(
-                    uri,
-                    self._client_headers,
-                    query,
-                    None,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def approvesepadirectdebit(self, token_id, body, context=None):
-        """
-        Resource /{merchantId}/tokens/{tokenId}/approvesepadirectdebit - Approve SEPA DD mandate
-        
-        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/tokens/approvesepadirectdebit.html
-
-        :param token_id:  str
-        :param body:      :class:`ingenico.connect.sdk.domain.token.approve_token_request.ApproveTokenRequest`
-        :param context:   :class:`ingenico.connect.sdk.call_context.CallContext`
-        :return: None
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: GlobalCollectException if something went wrong at the Ingenico ePayments platform,
-                   the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Ingenico ePayments platform returned any other error
-        """
-        path_context = {
-            "tokenId": token_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/tokens/{tokenId}/approvesepadirectdebit", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    None,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)

connect-sdk-python3-3.46.0/ingenico/connect/sdk/meta_data_provider.py

@@ -1,127 +0,0 @@
-import platform
-from base64 import b64encode
-import re
-
-from .request_header import RequestHeader
-from ingenico.connect.sdk.data_object import DataObject
-from ingenico.connect.sdk.defaultimpl.default_marshaller import DefaultMarshaller
-from ingenico.connect.sdk.domain.metadata.shopping_cart_extension import ShoppingCartExtension
-
-
-class IterProperty(object):
-    def __init__(self, func):
-        self.func = func
-
-    def __get__(self, instance, owner):
-        return self.func(owner)
-
-
-class MetaDataProvider:
-    """
-    Provides meta info about the server.
-    """
-    __SDK_VERSION = "3.46.0"
-    __SERVER_META_INFO_HEADER = "X-GCS-ServerMetaInfo"
-    __prohibited_headers = [__SERVER_META_INFO_HEADER, "X-GCS-Idempotence-Key",
-                            "Date", "Content-Type", "Authorization"]
-    __PROHIBITED_HEADERS = tuple(sorted(__prohibited_headers, key=str.lower))
-    __meta_data_headers = None
-
-    class ServerMetaInfo(DataObject):
-        platform_identifier = None
-        sdk_identifier = None
-        sdk_creator = None
-        integrator = None
-        shopping_cart_extension = None
-
-        def to_dictionary(self):
-            dictionary = super(MetaDataProvider.ServerMetaInfo, self).to_dictionary()
-            if self.platform_identifier is not None:
-                dictionary['platformIdentifier'] = self.platform_identifier
-            if self.sdk_identifier is not None:
-                dictionary['sdkIdentifier'] = self.sdk_identifier
-            if self.sdk_creator is not None:
-                dictionary['sdkCreator'] = self.sdk_creator
-            if self.integrator is not None:
-                dictionary['integrator'] = self.integrator
-            if self.shopping_cart_extension is not None:
-                dictionary['shoppingCartExtension'] = self.shopping_cart_extension.to_dictionary()
-            return dictionary
-
-        def from_dictionary(self, dictionary):
-            super(MetaDataProvider.ServerMetaInfo, self).from_dictionary(dictionary)
-            if 'platformIdentifier' in dictionary:
-                self.platform_identifier = dictionary['platformIdentifier']
-            if 'sdkIdentifier' in dictionary:
-                self.sdk_identifier = dictionary['sdkIdentifier']
-            if 'sdkCreator' in dictionary:
-                self.sdk_creator = dictionary['sdkCreator']
-            if 'integrator' in dictionary:
-                self.integrator = dictionary['integrator']
-            if 'shoppingCartExtension' in dictionary:
-                if not isinstance(dictionary['shoppingCartExtension'], dict):
-                    raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['shoppingCartExtension']))
-                self.shopping_cart_extension = ShoppingCartExtension.create_from_dictionary(dictionary['shoppingCartExtension'])
-            return self
-
-    def __init__(self, integrator, shopping_cart_extension=None,
-                 additional_request_headers=()):
-        MetaDataProvider.__validate_additional_request_headers(additional_request_headers)
-
-        def subber(name_or_value):
-            return re.sub(r'\r?\n(?:(?![\r\n])\s)*', " ", name_or_value).strip()
-        additional_request_headers = [RequestHeader(subber(header.name), subber(header.value)) for header in additional_request_headers]
-
-        server_meta_info = self.ServerMetaInfo()
-        server_meta_info.platform_identifier = self._platform_identifier
-        server_meta_info.sdk_identifier = self._sdk_identifier
-        server_meta_info.sdk_creator = "Ingenico"
-        server_meta_info.integrator = integrator
-        server_meta_info.shopping_cart_extension = shopping_cart_extension
-
-        server_meta_info_string = DefaultMarshaller.INSTANCE().marshal(server_meta_info)
-        server_meta_info_header = RequestHeader(self.__SERVER_META_INFO_HEADER, b64encode(server_meta_info_string.encode('utf-8')))
-        if not additional_request_headers:
-            self.__meta_data_headers = tuple([server_meta_info_header])
-        else:
-            request_headers = [server_meta_info_header]
-            request_headers.extend(additional_request_headers)
-            self.__meta_data_headers = tuple(request_headers)
-
-    @staticmethod
-    def __validate_additional_request_headers(additional_request_headers):
-        if additional_request_headers is not None:
-            for additional_request_header in additional_request_headers:
-                MetaDataProvider.__validate_additional_request_header(additional_request_header)
-
-    @staticmethod
-    def __validate_additional_request_header(additional_request_header):
-        try:
-            if additional_request_header.name in MetaDataProvider.__PROHIBITED_HEADERS:
-                raise ValueError("request header not allowed: " + str(additional_request_header))
-        except AttributeError:
-            raise AttributeError("Each request header should have an attribute 'name' and an attribute 'value'")
-
-    @IterProperty
-    def prohibited_headers(self):
-        return self.__PROHIBITED_HEADERS
-
-    @property
-    def meta_data_headers(self):
-        """
-        :return: The server related headers containing the META data to be
-         associated with the request (if any). This will always contain at least
-         an automatically generated header X-GCS-ServerMetaInfo.
-        """
-        return self.__meta_data_headers
-
-    @property
-    def _platform_identifier(self):
-        return platform.system() + " " + platform.release() + "/" + \
-               platform.version() + " Python/" + platform.python_version() + \
-               " (" + platform.python_implementation() + "; " + \
-               str(platform.python_compiler()) + ")"
-
-    @property
-    def _sdk_identifier(self):
-        return "Python3ServerSDK/v" + self.__SDK_VERSION

connect-sdk-python3-3.46.0/ingenico/connect/sdk/multipart_form_data_object.py

@@ -1,47 +0,0 @@
-import uuid
-
-
-class MultipartFormDataObject:
-    """
-    A representation of a multipart/form-data object.
-    """
-
-    def __init__(self):
-        self.__boundary = str(uuid.uuid4())
-        self.__content_type = "multipart/form-data; boundary=" + self.__boundary
-        self.__values = {}
-        self.__files = {}
-
-    @property
-    def boundary(self):
-        return self.__boundary
-
-    @property
-    def content_type(self):
-        return self.__content_type
-
-    @property
-    def values(self):
-        return self.__values
-
-    @property
-    def files(self):
-        return self.__files
-
-    def add_value(self, parameter_name, value):
-        if parameter_name is None or not parameter_name.strip():
-            raise ValueError("parameter_name is required")
-        if value is None:
-            raise ValueError("value is required")
-        if parameter_name in self.__values or parameter_name in self.__files:
-            raise ValueError("duplicate parameterName: " + parameter_name)
-        self.__values[parameter_name] = value
-
-    def add_file(self, parameter_name, uploadable_file):
-        if parameter_name is None or not parameter_name.strip():
-            raise ValueError("parameter_name is required")
-        if uploadable_file is None:
-            raise ValueError("uploadable_file is required")
-        if parameter_name in self.__values or parameter_name in self.__files:
-            raise ValueError("duplicate parameterName: " + parameter_name)
-        self.__files[parameter_name] = uploadable_file

connect-sdk-python3-3.46.0/ingenico/connect/sdk/multipart_form_data_request.py

@@ -1,10 +0,0 @@
-class MultipartFormDataRequest:
-    """
-    A representation of a multipart/form-data request.
-    """
-
-    def to_multipart_form_data_object(self):
-        """
-        :return: :class:`ingenico.connect.sdk.MultipartFormDataObject`
-        """
-        raise NotImplementedError

connect-sdk-python3-3.46.0/ingenico/connect/sdk/not_found_exception.py

@@ -1,10 +0,0 @@
-class NotFoundException(RuntimeError):
-    """
-    Indicates an exception that occurs when the requested resource is not found.
-    In normal usage of the SDK, this exception should not occur, however it is possible.
-    For example when path parameters are set with invalid values.
-    """
-
-    def __init__(self, exception, message=None):
-        super(NotFoundException, self).__init__(message, exception)
-        self.cause = exception

connect-sdk-python3-3.46.0/ingenico/connect/sdk/param_request.py

@@ -1,10 +0,0 @@
-class ParamRequest(object):
-    """
-    Represents a set of request parameters.
-    """
-
-    def to_request_parameters(self):
-        """
-        :return: list[:class:`ingenico.connect.sdk.RequestParam`] representing the HTTP request parameters
-        """
-        raise NotImplementedError

connect-sdk-python3-3.46.0/ingenico/connect/sdk/pooled_connection.py

@@ -1,25 +0,0 @@
-from .connection import Connection
-
-
-# noinspection PyAbstractClass
-class PooledConnection(Connection):
-    """
-    Represents a pooled connection to the Ingenico ePayments platform server.
-    Instead of setting up a new HTTP connection for each request, this
-    connection uses a pool of HTTP connections.
-    """
-
-    def close_idle_connections(self, idle_time):
-        """
-        Closes all HTTP connections that have been idle for the specified time.
-        This should also include all expired HTTP connections.
-
-        :param idle_time: a datetime.timedelta object indicating the idle time
-        """
-        raise NotImplementedError
-
-    def close_expired_connections(self):
-        """
-        Closes all expired HTTP connections.
-        """
-        raise NotImplementedError

connect-sdk-python3-3.46.0/ingenico/connect/sdk/proxy_configuration.py

@@ -1,101 +0,0 @@
-from urllib.parse import urlparse
-
-
-class ProxyConfiguration:
-    """
-    HTTP proxy configuration.
-
-    Can be initialised directly from a host and port or can be constructed from a uri using fromuri
-    """
-
-    def __init__(self, host, port, scheme="http", username=None, password=None):
-        if not host:
-            raise ValueError("host is required")
-        if not port:
-            raise ValueError("port is required")
-        if port <= 0 or port > 65535:
-            raise ValueError("""port "{}" is invalid""".format(port))
-        self.__scheme = scheme
-        self.__host = host
-        self.__port = port
-        self.__username = username
-        self.__password = password
-
-    @staticmethod
-    def from_uri(uri, username=None, password=None):
-        """
-        Constructs a ProxyConfiguration from a URI; if username and/or password
-        are given they will be used instead of corresponding data in the URI
-        """
-        parsed = urlparse(uri)
-        scheme = parsed.scheme
-        host = parsed.hostname + parsed.path
-        port = parsed.port
-        if username is None:
-            username = parsed.username
-        if password is None:
-            password = parsed.password
-        if port is None:
-            if scheme == "http":
-                port = 80
-            elif scheme == "https":
-                port = 443
-            else:
-                raise ValueError("unsupported scheme: " + scheme)
-        return ProxyConfiguration(scheme=scheme,
-                                  host=host,
-                                  port=port,
-                                  username=username,
-                                  password=password)
-
-    @property
-    def scheme(self):
-        return self.__scheme
-
-    @scheme.setter
-    def scheme(self, scheme):
-        self.__scheme = scheme
-
-    @property
-    def host(self):
-        return self.__host
-
-    @host.setter
-    def host(self, host):
-        self.__host = host
-
-    @property
-    def port(self):
-        return self.__port
-
-    @port.setter
-    def port(self, port):
-        self.__port = port
-
-    @property
-    def username(self):
-        return self.__username
-
-    @username.setter
-    def username(self, username):
-        self.__username = username
-
-    @property
-    def password(self):
-        return self.__password
-
-    @password.setter
-    def password(self, password):
-        self.__password = password
-
-    def __str__(self):
-        """
-        Return a proxy string in the form scheme://username:password@host:port
-        or scheme://host:port if authentication is absent
-
-        Supports HTTP Basic Auth
-        """
-        if self.username is None or self.password is None:
-            return r"{0}://{1}:{2}".format(self.scheme, self.host, self.port)
-        else:
-            return r"{0}://{3}:{4}@{1}:{2}".format(self.scheme, self.host, self.port, self.username, self.password)

connect-sdk-python3-3.46.0/ingenico/connect/sdk/reference_exception.py

@@ -1,12 +0,0 @@
-from .api_exception import ApiException
-
-
-class ReferenceException(ApiException):
-    """
-    Represents an error response from the Ingenico ePayments platform when a
-    non-existing or removed object is trying to be accessed.
-    """
-
-    def __init__(self, status_code, response_body, error_id, errors,
-                 message="the Ingenico ePayments platform returned a reference error response"):
-        super(ReferenceException, self).__init__(status_code, response_body, error_id, errors, message)

connect-sdk-python3-3.46.0/ingenico/connect/sdk/request_header.py

@@ -1,57 +0,0 @@
-class RequestHeader:
-    """
-    A single request header. Immutable.
-    """
-
-    def __init__(self, name, value):
-        if name is None or not name.strip():
-            raise ValueError("name is required")
-        self.__name = name
-        self.__value = value
-
-    @property
-    def name(self):
-        """
-        :return: The header name.
-        """
-        return self.__name
-
-    @property
-    def value(self):
-        """
-        :return: The un-encoded value.
-        """
-        return self.__value.decode('utf-8') if isinstance(self.__value, bytes) else self.__value
-
-    def __str__(self):
-        return self.__name + ":" + str(self.__value)
-
-
-def get_header_value(headers, header_name):
-    """
-    :return: The value of the header with the given name, or None if there was no such header.
-    """
-    if isinstance(headers, dict):
-        for name, value in headers.items():
-            if name.lower() == header_name.lower():
-                return value
-    elif headers is not None:
-        for header in headers:
-            if header.name.lower() == header_name.lower():
-                return header.value
-    return None
-
-
-def get_header(headers, header_name):
-    """
-    :return: The header with the given name, or None if there was no such header.
-    """
-    if isinstance(headers, dict):
-        for name, value in headers.items():
-            if name.lower() == header_name.lower():
-                return RequestHeader(name, value)
-    elif headers is not None:
-        for header in headers:
-            if header.name.lower() == header_name.lower():
-                return header
-    return None

connect-sdk-python3-3.46.0/ingenico/connect/sdk/request_param.py

@@ -1,27 +0,0 @@
-class RequestParam(object):
-    """
-    A single request parameter. Immutable.
-    """
-
-    def __init__(self, name, value):
-        if name is None or not name.strip():
-            raise ValueError("name is required")
-        self.__name = name
-        self.__value = value
-
-    @property
-    def name(self):
-        """
-        :return: The parameter name.
-        """
-        return self.__name
-
-    @property
-    def value(self):
-        """
-        :return: The un-encoded value.
-        """
-        return self.__value
-
-    def __str__(self):
-        return self.name + ":" + self.value