onlinepayments-sdk-python3 4.23.0__zip → 5.0.0__zip

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/domain/web_hooks_event.py

@@ -0,0 +1,174 @@
+from typing import Optional
+
+from .data_object import DataObject
+from .payment_response import PaymentResponse
+from .payout_response import PayoutResponse
+from .refund_response import RefundResponse
+from .token_response import TokenResponse
+
+class WebhooksEvent(DataObject):
+
+    __api_version: Optional[str] = None
+    __created: Optional[str] = None
+    __id: Optional[str] = None
+    __merchant_id: Optional[str] = None
+    __type: Optional[str] = None
+    __payment: Optional[PaymentResponse] = None
+    __payout: Optional[PayoutResponse] = None
+    __refund: Optional[RefundResponse] = None
+    __token: Optional[TokenResponse] = None
+
+    @property
+    def api_version(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__api_version
+
+    @api_version.setter
+    def api_version(self, value: Optional[str]) -> None:
+        self.__api_version = value
+
+    @property
+    def created(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__created
+
+    @created.setter
+    def created(self, value: Optional[str]) -> None:
+        self.__created = value
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def merchant_id(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__merchant_id
+
+    @merchant_id.setter
+    def merchant_id(self, value: Optional[str]) -> None:
+        self.__merchant_id = value
+
+    @property
+    def type(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__type
+
+    @type.setter
+    def type(self, value: Optional[str]) -> None:
+        self.__type = value
+
+    @property
+    def payment(self) -> Optional[PaymentResponse]:
+        """
+        Type: PaymentResponse
+        """
+        return self.__payment
+
+    @payment.setter
+    def payment(self, value: Optional[PaymentResponse]) -> None:
+        self.__payment = value
+
+    @property
+    def payout(self) -> Optional[PayoutResponse]:
+        """
+        Type: PayoutResponse
+        """
+        return self.__payout
+
+    @payout.setter
+    def payout(self, value: Optional[PayoutResponse]) -> None:
+        self.__payout = value
+
+    @property
+    def refund(self) -> Optional[RefundResponse]:
+        """
+        Type: RefundResponse
+        """
+        return self.__refund
+
+    @refund.setter
+    def refund(self, value: Optional[RefundResponse]) -> None:
+        self.__refund = value
+
+    @property
+    def token(self) -> Optional[TokenResponse]:
+        """
+        Type: TokenResponse
+        """
+        return self.__token
+
+    @token.setter
+    def token(self, value: Optional[TokenResponse]) -> None:
+        self.__token = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(WebhooksEvent, self).to_dictionary()
+        if self.api_version is not None:
+            dictionary['apiVersion'] = self.api_version
+        if self.created is not None:
+            dictionary['created'] = self.created
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.merchant_id is not None:
+            dictionary['merchantId'] = self.merchant_id
+        if self.type is not None:
+            dictionary['type'] = self.type
+        if self.payment is not None:
+            dictionary['payment'] = self.payment
+        if self.payout is not None:
+            dictionary['payout'] = self.payout
+        if self.refund is not None:
+            dictionary['refund'] = self.refund
+        if self.token is not None:
+            dictionary['token'] = self.token
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'WebhooksEvent':
+        super(WebhooksEvent, self).from_dictionary(dictionary)
+        if 'apiVersion' in dictionary:
+            self.api_version = dictionary['apiVersion']
+        if 'created' in dictionary:
+            self.created = dictionary['created']
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'merchantId' in dictionary:
+            self.merchant_id = dictionary['merchantId']
+        if 'type' in dictionary:
+            self.type = dictionary['type']
+        if 'payment' in dictionary:
+            if not isinstance(dictionary['payment'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payment']))
+            value = PaymentResponse()
+            self.__payment = value.from_dictionary(dictionary['payment'])
+        if 'payout' in dictionary:
+            if not isinstance(dictionary['payout'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payout']))
+            value = PayoutResponse()
+            self.__payout = value.from_dictionary(dictionary['payout'])
+        if 'refund' in dictionary:
+            if not isinstance(dictionary['refund'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['refund']))
+            value = RefundResponse()
+            self.__refund = value.from_dictionary(dictionary['refund'])
+        if 'token' in dictionary:
+            if not isinstance(dictionary['token'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['token']))
+            value = TokenResponse()
+            self.__token = value.from_dictionary(dictionary['token'])
+        return self

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/exception_factory.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Any, List, Optional
+
+from .api_exception import ApiException
+from .authorization_exception import AuthorizationException
+from .call_context import CallContext
+from .declined_payment_exception import DeclinedPaymentException
+from .declined_payout_exception import DeclinedPayoutException
+from .declined_refund_exception import DeclinedRefundException
+from .idempotence_exception import IdempotenceException
+from .platform_exception import PlatformException
+from .reference_exception import ReferenceException
+from .validation_exception import ValidationException
+
+from onlinepayments.sdk.domain.api_error import APIError
+from onlinepayments.sdk.domain.error_response import ErrorResponse
+from onlinepayments.sdk.domain.payment_error_response import PaymentErrorResponse
+from onlinepayments.sdk.domain.payout_error_response import PayoutErrorResponse
+from onlinepayments.sdk.domain.refund_error_response import RefundErrorResponse
+
+
+def create_exception(status_code: int, body: str, error_object: Any, context: Optional[CallContext]) -> Exception:
+    """Return a raisable API exception based on the error object given"""
+    def create_exception_from_response_fields(error_id: Optional[str], errors: Optional[List[APIError]]) -> Exception:
+        if is_idempotence_error(errors):
+            return IdempotenceException(context.idempotence_key, context.idempotence_request_timestamp,
+                                        status_code, body, error_id, errors)
+        # get error based on status code, defaulting to ApiException
+        return ERROR_MAP.get(status_code, ApiException)(status_code, body, error_id, errors)
+
+    def is_idempotence_error(errors: Optional[List[APIError]]) -> bool:
+        return status_code == 409 \
+            and context is not None \
+            and context.idempotence_key is not None \
+            and errors is not None \
+            and len(errors) == 1 \
+            and errors[0].error_code == '1409'
+
+    if isinstance(error_object, PaymentErrorResponse):
+        if error_object.payment_result is not None:
+            return DeclinedPaymentException(status_code=status_code,
+                                            response_body=body,
+                                            response=error_object)
+        return create_exception_from_response_fields(error_object.error_id, error_object.errors)
+    if isinstance(error_object, PayoutErrorResponse):
+        if error_object.payout_result is not None:
+            return DeclinedPayoutException(status_code=status_code,
+                                           response_body=body,
+                                           response=error_object)
+        return create_exception_from_response_fields(error_object.error_id, error_object.errors)
+    if isinstance(error_object, RefundErrorResponse):
+        if error_object.refund_result is not None:
+            return DeclinedRefundException(status_code=status_code,
+                                           response_body=body,
+                                           response=error_object)
+        return create_exception_from_response_fields(error_object.error_id, error_object.errors)
+    if not isinstance(error_object, ErrorResponse):
+        raise ValueError("Unsupported error object encountered: {}".format(error_object.__class__.__name__))
+
+    return create_exception_from_response_fields(error_object.error_id, error_object.errors)
+
+
+ERROR_MAP = {
+    400: ValidationException,
+    403: AuthorizationException,
+    404: ReferenceException,
+    409: ReferenceException,  # idempotence has already been tested
+    410: ReferenceException,
+    500: PlatformException,
+    502: PlatformException,
+    503: PlatformException,
+}

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/factory.py

@@ -0,0 +1,127 @@
+from configparser import ConfigParser
+from typing import Optional, Union
+
+from .client import Client
+from .i_client import IClient
+from .communicator import Communicator
+from .i_communicator import ICommunicator
+from .communicator_configuration import CommunicatorConfiguration
+
+from onlinepayments.sdk.authentication.authorization_type import AuthorizationType
+from onlinepayments.sdk.authentication.authenticator import Authenticator
+from onlinepayments.sdk.authentication.v1hmac_authenticator import V1HmacAuthenticator
+from onlinepayments.sdk.communication.connection import Connection
+from onlinepayments.sdk.communication.default_connection import DefaultConnection
+from onlinepayments.sdk.communication.metadata_provider import MetadataProvider
+from onlinepayments.sdk.communication.i_metadata_provider import IMetadataProvider
+from onlinepayments.sdk.json.default_marshaller import DefaultMarshaller
+from onlinepayments.sdk.json.marshaller import Marshaller
+
+
+class Factory(object):
+    """
+    Online Payments platform factory for several SDK components.
+    """
+
+    @staticmethod
+    def create_configuration(configuration_file_name: Union[str, bytes], api_key_id: str, secret_api_key: str) -> CommunicatorConfiguration:
+        """
+        Creates a CommunicatorConfiguration based on the configuration values in configuration_file_name, api_key_id and secret_api_key.
+        """
+        try:
+            parser = ConfigParser()
+            with open(configuration_file_name) as f:
+                parser.read_file(f)
+            return CommunicatorConfiguration(properties=parser,
+                                             api_key_id=api_key_id,
+                                             secret_api_key=secret_api_key)
+        except IOError as e:
+            raise RuntimeError("Unable to read configuration located at {}".format(e.filename), e) from e
+
+    @staticmethod
+    def create_communicator_from_configuration(communicator_configuration: CommunicatorConfiguration,
+                                               metadata_provider: Optional[IMetadataProvider] = None,
+                                               connection: Optional[Connection] = None,
+                                               authenticator: Optional[Authenticator] = None,
+                                               marshaller: Optional[Marshaller] = None) -> ICommunicator:
+        """
+        Creates a Communicator based on the configuration stored in the CommunicatorConfiguration argument
+        """
+        if metadata_provider is None:
+            metadata_provider = MetadataProvider(integrator=communicator_configuration.integrator,
+                                                 shopping_cart_extension=communicator_configuration.shopping_cart_extension)
+        if connection is None:
+            connection = DefaultConnection(communicator_configuration.connect_timeout,
+                                           communicator_configuration.socket_timeout,
+                                           communicator_configuration.max_connections,
+                                           communicator_configuration.proxy_configuration)
+        if authenticator is None:
+            authenticator = Factory.__get_authenticator(communicator_configuration)
+        if marshaller is None:
+            marshaller = DefaultMarshaller.instance()
+        return Communicator(api_endpoint=communicator_configuration.api_endpoint,
+                            metadata_provider=metadata_provider,
+                            connection=connection,
+                            authenticator=authenticator,
+                            marshaller=marshaller)
+
+    @staticmethod
+    def __get_authenticator(communicator_configuration: CommunicatorConfiguration) -> Authenticator:
+        if communicator_configuration.authorization_type == AuthorizationType.V1HMAC:
+            return V1HmacAuthenticator(communicator_configuration)
+        raise RuntimeError("Unknown authorizationType " + communicator_configuration.authorization_type)
+
+    @staticmethod
+    def create_communicator_from_file(configuration_file_name: Union[str, bytes], api_key_id: str, secret_api_key: str,
+                                      metadata_provider: Optional[IMetadataProvider] = None,
+                                      connection: Optional[Connection] = None,
+                                      authenticator: Optional[Authenticator] = None,
+                                      marshaller: Optional[Marshaller] = None) -> ICommunicator:
+        """
+        Creates a Communicator based on the configuration values in configuration_file_name, api_id_key and secret_api_key.
+        """
+        configuration = Factory.create_configuration(configuration_file_name, api_key_id, secret_api_key)
+        return Factory.create_communicator_from_configuration(configuration,
+                                                              metadata_provider=metadata_provider,
+                                                              connection=connection,
+                                                              authenticator=authenticator,
+                                                              marshaller=marshaller)
+
+    @staticmethod
+    def create_client_from_configuration(communicator_configuration: CommunicatorConfiguration,
+                                         metadata_provider: Optional[IMetadataProvider] = None,
+                                         connection: Optional[Connection] = None,
+                                         authenticator: Optional[Authenticator] = None,
+                                         marshaller: Optional[Marshaller] = None) -> IClient:
+        """
+        Create a Client based on the configuration stored in the CommunicatorConfiguration argument
+        """
+        communicator = Factory.create_communicator_from_configuration(communicator_configuration,
+                                                                      metadata_provider=metadata_provider,
+                                                                      connection=connection,
+                                                                      authenticator=authenticator,
+                                                                      marshaller=marshaller)
+        return Client(communicator)
+
+    @staticmethod
+    def create_client_from_communicator(communicator: ICommunicator) -> IClient:
+        """
+        Create a Client based on the settings stored in the Communicator argument
+        """
+        return Client(communicator)
+
+    @staticmethod
+    def create_client_from_file(configuration_file_name: Union[str, bytes], api_key_id: str, secret_api_key: str,
+                                metadata_provider: Optional[IMetadataProvider] = None,
+                                connection: Optional[Connection] = None,
+                                authenticator: Optional[Authenticator] = None,
+                                marshaller: Optional[Marshaller] = None) -> IClient:
+        """
+        Creates a Client based on the configuration values in configuration_file_name, api_key_id and secret_api_key.
+        """
+        communicator = Factory.create_communicator_from_file(configuration_file_name, api_key_id, secret_api_key,
+                                                             metadata_provider=metadata_provider,
+                                                             connection=connection,
+                                                             authenticator=authenticator,
+                                                             marshaller=marshaller)
+        return Client(communicator)

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/i_client.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from abc import abstractmethod
+from datetime import timedelta
+from typing import Optional
+
+from onlinepayments.sdk.log.body_obfuscator import BodyObfuscator
+from onlinepayments.sdk.log.communicator_logger import CommunicatorLogger
+from onlinepayments.sdk.log.header_obfuscator import HeaderObfuscator
+from onlinepayments.sdk.log.logging_capable import LoggingCapable
+from onlinepayments.sdk.log.obfuscation_capable import ObfuscationCapable
+from onlinepayments.sdk.merchant.i_merchant_client import IMerchantClient
+
+
+class IClient(LoggingCapable, ObfuscationCapable):
+    """
+    Payment platform client interface.
+
+    This client and all its child clients are bound to one specific value for the X-GCS-ClientMetaInfo header.
+    To get a new client with a different header value, use with_client_meta_info.
+
+    Thread-safe.
+    """
+
+    @abstractmethod
+    def with_client_meta_info(self, client_meta_info: Optional[str]) -> 'Client':
+        """
+        :param client_meta_info: JSON string containing the metadata for the client
+        :return: a new Client which uses the passed metadata for the X-GCS-ClientMetaInfo header.
+        :raise MarshallerSyntaxException: if the given clientMetaInfo is not a valid JSON string
+        """
+
+    @abstractmethod
+    def close_idle_connections(self, idle_time: timedelta) -> None:
+        """
+        Utility method that delegates the call to this client's communicator.
+
+        :param idle_time: a datetime.timedelta object indicating the idle time
+        """
+
+    @abstractmethod
+    def close_expired_connections(self) -> None:
+        """
+        Utility method that delegates the call to this client's communicator.
+        """
+
+    @abstractmethod
+    def set_body_obfuscator(self, body_obfuscator: BodyObfuscator) -> None:
+        """"""
+
+    @abstractmethod
+    def set_header_obfuscator(self, header_obfuscator: HeaderObfuscator) -> None:
+        """"""
+
+    @abstractmethod
+    def enable_logging(self, communicator_logger: CommunicatorLogger) -> None:
+        """"""
+
+    @abstractmethod
+    def disable_logging(self) -> None:
+        """"""
+
+    @abstractmethod
+    def close(self) -> None:
+        """
+        Releases any system resources associated with this object.
+        """
+
+    @abstractmethod
+    def merchant(self, merchant_id: str) -> IMerchantClient:
+        """
+        Resource /v2/{merchantId}
+
+        :param merchant_id:  str
+        :return: :class:`onlinepayments.sdk.merchant.i_merchant_client.IMerchantClient`
+        """

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/i_communicator.py

@@ -0,0 +1,180 @@
+from abc import abstractmethod
+from typing import List, Optional, Type, Tuple, Mapping, Iterable, Any
+
+from onlinepayments.sdk.call_context import CallContext
+from onlinepayments.sdk.communication.param_request import ParamRequest
+from onlinepayments.sdk.communication.request_header import RequestHeader
+from onlinepayments.sdk.json.marshaller import Marshaller, T
+from onlinepayments.sdk.log.logging_capable import LoggingCapable
+from onlinepayments.sdk.log.obfuscation_capable import ObfuscationCapable
+
+BinaryResponse = Tuple[Mapping[str, str], Iterable[bytes]]
+
+
+class ICommunicator(LoggingCapable, ObfuscationCapable):
+    """
+    Used to communicate with the Online Payments platform web services.
+
+    It contains all the logic to transform a request object to an HTTP request and an HTTP response to a response object.
+    """
+
+    @abstractmethod
+    def close(self) -> None:
+        """
+        Releases any system resources associated with this object.
+        """
+
+    @abstractmethod
+    def get(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+            request_parameters: Optional[ParamRequest],
+            response_type: Type[T],
+            context: Optional[CallContext]) -> T:
+        """
+        Corresponds to the HTTP GET method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param response_type: The type of response to return.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def get_with_binary_response(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+                                 request_parameters: Optional[ParamRequest],
+                                 context: Optional[CallContext]) -> BinaryResponse:
+        """
+        Corresponds to the HTTP GET method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def delete(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+               request_parameters: Optional[ParamRequest],
+               response_type: Type[T],
+               context: Optional[CallContext]) -> T:
+        """
+        Corresponds to the HTTP DELETE method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param response_type: The type of response to return.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def delete_with_binary_response(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+                                    request_parameters: Optional[ParamRequest],
+                                    context: Optional[CallContext]) -> BinaryResponse:
+        """
+        Corresponds to the HTTP DELETE method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def post_with_binary_response(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+                                  request_parameters: Optional[ParamRequest], request_body: Any,
+                                  context: Optional[CallContext]) -> BinaryResponse:
+        """
+        Corresponds to the HTTP POST method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param request_body: The optional request body to send.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def post(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+             request_parameters: Optional[ParamRequest], request_body: Any,
+             response_type: Type[T],
+             context: Optional[CallContext]) -> T:
+        """
+        Corresponds to the HTTP POST method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param request_body: The optional request body to send.
+        :param response_type: The type of response to return.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def put_with_binary_response(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+                                 request_parameters: Optional[ParamRequest], request_body: Any,
+                                 context: Optional[CallContext]) -> BinaryResponse:
+        """
+        Corresponds to the HTTP PUT method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param request_body: The optional request body to send.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def put(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+            request_parameters: Optional[ParamRequest], request_body: Any,
+            response_type: Type[T],
+            context: Optional[CallContext]) -> T:
+        """
+        Corresponds to the HTTP PUT method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param request_body: The optional request body to send.
+        :param response_type: The type of response to return.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def close_idle_connections(self, idle_time):
+        """
+        Utility method that delegates the call to this communicator's connection
+        if that's an instance of PooledConnection. If not this method does nothing.
+
+        :param idle_time: a datetime.timedelta object indicating the idle time
+        """
+
+    @abstractmethod
+    def close_expired_connections(self):
+        """
+        Utility method that delegates the call to this communicator's connection
+        if that's an instance of PooledConnection. If not this method does nothing.
+        """
+
+    @property
+    @abstractmethod
+    def marshaller(self) -> Marshaller:
+        """
+        :return: The Marshaller object associated with this communicator. Never None.
+        """

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/idempotence_exception.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .api_exception import ApiException
+
+from onlinepayments.sdk.domain.api_error import APIError
+
+
+class IdempotenceException(ApiException):
+    """
+    Represents an error response from the payment platform when an idempotent request failed because the first request has not finished yet.
+    """
+
+    def __init__(self, idempotence_key: str, idempotence_request_timestamp: int,
+                 status_code: int, response_body: str, error_id: Optional[str], errors: Optional[List[APIError]],
+                 message: str = "the payment platform returned a duplicate request error response"):
+        super(IdempotenceException, self).__init__(status_code, response_body, error_id, errors, message)
+        self.__idempotence_key = idempotence_key
+        self.__idempotence_request_timestamp = idempotence_request_timestamp
+
+    @property
+    def idempotence_key(self) -> str:
+        """
+        :return: The key that was used for the idempotent request.
+        """
+        return self.__idempotence_key
+
+    @property
+    def idempotence_request_timestamp(self) -> int:
+        """
+        :return: The request timestamp of the first idempotent request with the same key.
+        """
+        return self.__idempotence_request_timestamp