connect-sdk-python2 3.45.0__zip → 3.47.0__zip

connect-sdk-python2-3.45.0/ingenico/connect/sdk/factory.py

@@ -1,155 +0,0 @@
-from ConfigParser import ConfigParser
-
-from communicator import Communicator
-from communicator_configuration import CommunicatorConfiguration
-from client import Client
-from ingenico.connect.sdk.defaultimpl.default_authenticator import \
-    DefaultAuthenticator
-from ingenico.connect.sdk.defaultimpl.default_connection import \
-    DefaultConnection
-from ingenico.connect.sdk.defaultimpl.default_marshaller import \
-    DefaultMarshaller
-from meta_data_provider import MetaDataProvider
-from session import Session
-
-
-class Factory:
-    """
-    Ingenico ePayments platform factory for several SDK components.
-    """
-
-    def __init__(self):
-        pass
-
-    @staticmethod
-    def create_configuration(configuration_file_name, api_key_id,
-                             secret_api_key):
-        """
-        Creates a CommunicatorConfiguration based on the configuration
-        values in configuration_file_name, api_key_id and secret_api_key.
-        """
-        try:
-            parser = ConfigParser()
-            parser.read(configuration_file_name)
-            with open(configuration_file_name) as f:
-                parser.readfp(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)
-
-    @staticmethod
-    def create_session_from_configuration(communicator_configuration,
-                                          meta_data_provider=None,
-                                          connection=None, authenticator=None):
-        """
-        Creates a Session based on the configuration stored in the
-        CommunicatorConfiguration argument
-        """
-        # If an authenticator is not given,  api_key_id and secret_api_key are
-        # used to create a DefaultAuthenticator used to create the session.
-        if meta_data_provider is None:
-            meta_data_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 = DefaultAuthenticator(
-                communicator_configuration.authorization_type,
-                communicator_configuration.api_key_id,
-                communicator_configuration.secret_api_key)
-        return Session(api_endpoint=communicator_configuration.api_endpoint,
-                       meta_data_provider=meta_data_provider,
-                       connection=connection, authenticator=authenticator)
-
-    @staticmethod
-    def create_session_from_file(configuration_file_name, api_key_id,
-                                 secret_api_key,
-                                 meta_data_provider=None,
-                                 connection=None, authenticator=None):
-        """
-        Creates a Session 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_session_from_configuration(
-            configuration,
-            meta_data_provider=meta_data_provider,
-            connection=connection,
-            authenticator=authenticator)
-
-    @staticmethod
-    def create_communicator_from_session(session):
-        """
-        Create a Communicator based on the settings stored in the Session
-        argument
-        """
-        return Communicator(session, DefaultMarshaller.INSTANCE())
-
-    @staticmethod
-    def create_communicator_from_configuration(communicator_configuration):
-        """
-        Create a Communicator based on the configuration stored in the
-        CommunicatorConfiguration argument
-        """
-        session = Factory.create_session_from_configuration(
-            communicator_configuration)
-        return Communicator(session, DefaultMarshaller.INSTANCE())
-
-    @staticmethod
-    def create_communicator_from_file(configuration_file_name, api_key_id,
-                                      secret_api_key):
-        """
-        Creates a Communicator based on the configuration values in
-        configuration_file_name, api_key_id and secret_api_key.
-        """
-        configuration = Factory.create_configuration(configuration_file_name,
-                                                     api_key_id, secret_api_key)
-        session = Factory.create_session_from_configuration(configuration)
-        return Communicator(session, DefaultMarshaller.INSTANCE())
-
-    @staticmethod
-    def create_client_from_configuration(communicator_configuration):
-        """
-        Create a Client based on the configuration stored in the
-        CommunicatorConfiguration argument
-        """
-        communicator = Factory.create_communicator_from_configuration(
-            communicator_configuration)
-        return Client(communicator)
-
-    @staticmethod
-    def create_client_from_communicator(communicator):
-        """
-        Create a Client based on the settings stored in the Communicator
-        argument
-        """
-        return Client(communicator)
-
-    @staticmethod
-    def create_client_from_session(session):
-        """
-        Create a Client based on the settings stored in the Session argument
-        """
-        communicator = Factory.create_communicator_from_session(session)
-        return Client(communicator)
-
-    @staticmethod
-    def create_client_from_file(configuration_file_name, api_key_id,
-                                secret_api_key):
-        """
-        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)
-        return Client(communicator)

connect-sdk-python2-3.45.0/ingenico/connect/sdk/global_collect_exception.py

@@ -1,13 +0,0 @@
-from api_exception import ApiException
-
-
-class GlobalCollectException(ApiException):
-    """
-    Represents an error response from the Ingenico ePayments platform when something
-    went wrong at the Ingenico ePayments platform or further downstream.
-    """
-
-    def __init__(self, status_code, response_body, error_id, errors,
-                 message="the Ingenico ePayments platform returned an error response"):
-        super(GlobalCollectException, self).__init__(status_code, response_body,
-                                                     error_id, errors, message)

connect-sdk-python2-3.45.0/ingenico/connect/sdk/idempotence_exception.py

@@ -1,31 +0,0 @@
-from api_exception import ApiException
-
-
-class IdempotenceException(ApiException):
-    """
-    Represents an error response from the Ingenico ePayments platform when an
-    idempotent request failed because the first request has not finished yet.
-    """
-
-    def __init__(self, idempotence_key, idempotence_request_timestamp,
-                 status_code, response_body, error_id, errors,
-                 message="the Ingenico ePayments 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):
-        """
-        :return: The key that was used for the idempotent request.
-        """
-        return self.__idempotence_key
-
-    @property
-    def idempotence_request_timestamp(self):
-        """
-        :return: The request timestamp of the first idempotent request with the
-         same key.
-        """
-        return self.__idempotence_request_timestamp

connect-sdk-python2-3.45.0/ingenico/connect/sdk/log/log_message.py

@@ -1,88 +0,0 @@
-from body_obfuscator import BodyObfuscator
-from header_obfuscator import HeaderObfuscator
-
-
-class LogMessage(object):
-    """
-    A utility class to build log messages.
-    """
-    __request_id = None
-    __headers = None
-    __body = None
-    __content_type = None
-    __header_list = None
-    __body_obfuscator = None
-    __header_obfuscator = None
-
-    def __init__(self, request_id,
-                 body_obfuscator=BodyObfuscator.default_body_obfuscator(),
-                 header_obfuscator=HeaderObfuscator.default_header_obfuscator()):
-        if not request_id:
-            raise ValueError("request_id is required")
-        if not body_obfuscator:
-            raise ValueError("body_obfuscator is required")
-        if not header_obfuscator:
-            raise ValueError("header_obfuscator is required")
-        self.__request_id = request_id
-        self.__headers = ""
-        self.__header_list = []
-        self.__body_obfuscator = body_obfuscator
-        self.__header_obfuscator = header_obfuscator
-
-    @property
-    def request_id(self):
-        return self.__request_id
-
-    @property
-    def headers(self):
-        return str(self.__headers)
-
-    @property
-    def body(self):
-        return self.__body
-
-    @property
-    def content_type(self):
-        return self.__content_type
-
-    def add_header(self, name, value):
-        if self.__headers:
-            self.__headers += ", "
-        self.__headers += name + "=\""
-        if value is not None and value.lower() != 'none':
-            obfuscated_value = self.__header_obfuscator.obfuscate_header(name, value)
-            self.__headers += obfuscated_value
-            self.__header_list.append((name, "\"" + obfuscated_value + "\""))
-        else:
-            self.__header_list.append((name, "\"\""))
-        self.__headers += "\""
-
-    def set_body(self, body, content_type, charset=None):
-        self.__content_type = content_type
-        if self.__is_binary(content_type):
-            self.__body = "<binary content>"
-        else:
-            self.__body = self.__body_obfuscator.obfuscate_body(body, charset)
-
-    def set_binary_body(self, content_type):
-        if not self.__is_binary(content_type):
-            raise ValueError("Not a binary content type: " + content_type)
-        self.__content_type = content_type
-        self.__body = "<binary content>"
-
-    def __is_binary(self, 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 empty_if_none(self, value):
-        if value is not None:
-            return value
-        return ""
-
-    def get_message(self):
-        raise NotImplementedError
-
-    def get_header_list(self):
-        return self.__header_list

connect-sdk-python2-3.45.0/ingenico/connect/sdk/log/python_communicator_logger.py

@@ -1,52 +0,0 @@
-from ingenico.connect.sdk.log.communicator_logger import \
-    CommunicatorLogger
-
-
-class PythonCommunicatorLogger(CommunicatorLogger):
-    """
-    A communicator logger that is backed by the log library.
-    """
-
-    def __init__(self, logger, log_level, error_log_level=False):
-        """
-        Logs messages to the argument logger using the argument log_level.
-        If absent, the error_log_level will be equal to the log_level.
-        Note that if the CommunicatorLogger's log level is lower than the
-        argument logger's log level (e.g. the CommunicatorLogger is given
-        log.INFO as level and the argument logger has a level of
-        log.WARNING), then nothing will be logged to the logger.
-
-        :param logger: the logger to log to
-        :param log_level: the log level that will be used for non-error
-         messages logged via the CommunicatorLogger
-        :param error_log_level: the log level that will be used for error
-         messages logged via the CommunicatorLogger.
-        """
-        CommunicatorLogger.__init__(self)
-        if not error_log_level:
-            error_log_level = log_level
-        if logger is None:
-            raise ValueError("logger is required")
-        if log_level is None:
-            raise ValueError("log_level is required")
-        if error_log_level is None:
-            raise ValueError("error_log_level is required")
-        self.__logger = logger
-        self.__log_level = log_level
-        self.__error_log_level = error_log_level
-
-    def log(self, message, thrown=None):
-        """
-        Log a message to the underlying logger.
-        If thrown is absent, the message will be logged with the
-        CommunicatorLogger's log_level, if a thrown object is provided,
-        the message and exception will be logged with the CommunicatorLogger's
-        error_log_level.
-
-        :param message: the message to be logged
-        :param thrown: an optional throwable object
-        """
-        if not thrown:
-            self.__logger.log(self.__log_level, message)
-        else:
-            self.__logger.log(self.__error_log_level, message, thrown)

connect-sdk-python2-3.45.0/ingenico/connect/sdk/log/request_log_message.py

@@ -1,30 +0,0 @@
-from body_obfuscator import BodyObfuscator
-from header_obfuscator import HeaderObfuscator
-from log_message import LogMessage
-
-
-class RequestLogMessage(LogMessage):
-    """
-    A utility class to build request log messages.
-    """
-
-    def __init__(self, request_id, method, uri,
-                 body_obfuscator=BodyObfuscator.default_body_obfuscator(),
-                 header_obfuscator=HeaderObfuscator.default_header_obfuscator()):
-        super(RequestLogMessage, self).__init__(request_id, body_obfuscator, header_obfuscator)
-        self.method = method
-        self.uri = uri
-
-    def get_message(self):
-        string = "Outgoing request (requestId='" + \
-                 str(self.request_id) + "'):\n" + \
-                 "  method:       " + \
-                 self.empty_if_none("'" + self.method + "'") + "\n  uri:          " + \
-                 self.empty_if_none("'" + self.uri + "'") + "\n  headers:      " + \
-                 self.headers
-        body = self.body
-        if body is None:
-            return string
-        else:
-            return string + "\n  content-type: '" + self.empty_if_none(self.content_type) + "'" + \
-                   "\n  body:         '" + body + "'"

connect-sdk-python2-3.45.0/ingenico/connect/sdk/log/response_log_message.py

@@ -1,46 +0,0 @@
-from body_obfuscator import BodyObfuscator
-from header_obfuscator import HeaderObfuscator
-from log_message import LogMessage
-
-
-class ResponseLogMessage(LogMessage):
-    """
-    A utility class to build request log messages.
-    """
-
-    def __init__(self, request_id, status_code, duration=-1,
-                 body_obfuscator=BodyObfuscator.default_body_obfuscator(),
-                 header_obfuscator=HeaderObfuscator.default_header_obfuscator()):
-        super(ResponseLogMessage, self).__init__(request_id, body_obfuscator, header_obfuscator)
-        self.__status_code = status_code
-        if duration is False:
-            self.__duration = -1
-        else:
-            self.__duration = duration
-
-    def get_duration(self):
-        return self.__duration
-
-    def get_status_code(self):
-        return self.__status_code
-
-    def get_message(self):
-        if self.__duration < 0:
-            return "Incoming response (requestId='" + \
-                   self.request_id + "'):\n" + \
-                   "  status_code:  " + str(
-                       self.__status_code) + "\n  headers:      " + \
-                   self.headers + "\n  content-type: " + \
-                   self.empty_if_none(
-                       self.content_type) + "\n  body:         " + \
-                   self.empty_if_none(self.body)
-
-        else:
-            return "Incoming response (requestId='" + \
-                   self.request_id + "', " + str(self.__duration) + " ms):\n" + \
-                   "  status_code:  " + (
-                       str(self.__status_code) + "\n  headers:      " +
-                       self.headers + "\n  content-type: " +
-                       self.empty_if_none(
-                           self.content_type) + "\n  body:         " +
-                       self.empty_if_none(self.body)).encode('utf-8', errors='backslashreplace')

connect-sdk-python2-3.45.0/ingenico/connect/sdk/log/sys_out_communicator_logger.py

@@ -1,40 +0,0 @@
-from __future__ import print_function
-
-from datetime import datetime
-from threading import Lock
-
-from ingenico.connect.sdk.log.python_communicator_logger import \
-    CommunicatorLogger
-
-
-class SysOutCommunicatorLogger(CommunicatorLogger):
-    """
-    A communicator logger that prints its message to sys.stdout
-    It includes a timestamp in yyyy-MM-ddTHH:mm:ss format in the system time zone.
-    """
-
-    def __init__(self):
-        CommunicatorLogger.__init__(self)
-
-    _global_lock = Lock()
-    _old_print = print
-
-    @staticmethod
-    def INSTANCE():
-        return _SYS_OUT_COMMUNICATOR_LOGGER_INSTANCE
-
-    def __print(self, *a):
-        with self._global_lock:
-            self._old_print(*a)
-
-    def log(self, message, thrown=None):
-        # Make sure the same object is used for locking and printing
-        self.__print(self.__get_date_prefix() + message)
-        if thrown:
-            self.__print(str(thrown))
-
-    def __get_date_prefix(self):
-        return datetime.now().strftime("%Y-%m-%dT%H:%M:%S ")
-
-
-_SYS_OUT_COMMUNICATOR_LOGGER_INSTANCE = SysOutCommunicatorLogger()

connect-sdk-python2-3.45.0/ingenico/connect/sdk/marshaller.py

@@ -1,25 +0,0 @@
-class Marshaller(object):
-    """
-    Used to marshal and unmarshal Ingenico ePayments platform request and response
-    objects to and from JSON.
-    """
-
-    def marshal(self, request_object):
-        """
-        Marshal a request object to a JSON string.
-
-        :param request_object: the object to marshal into a serialized JSON string
-        :return: the serialized JSON string of the request_object
-        """
-        raise NotImplementedError
-
-    def unmarshal(self, response_json, type_class):
-        """
-        Unmarshal a JSON string to a response object.
-
-        :param response_json: the json body that should be unmarshalled
-        :param type_class: The class to which the response_json should be unmarshalled
-        :raise: MarshallerSyntaxException if the JSON is not a valid
-         representation for an object of the given type
-        """
-        raise NotImplementedError

connect-sdk-python2-3.45.0/ingenico/connect/sdk/merchant/__init__.py

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

connect-sdk-python2-3.45.0/ingenico/connect/sdk/merchant/captures/__init__.py

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

connect-sdk-python2-3.45.0/ingenico/connect/sdk/merchant/captures/captures_client.py

@@ -1,96 +0,0 @@
-#
-# This class was auto-generated from the API references found at
-# https://epayments-api.developer-ingenico.com/s2sapi/v1/
-#
-from ingenico.connect.sdk.api_resource import ApiResource
-from ingenico.connect.sdk.response_exception import ResponseException
-from ingenico.connect.sdk.domain.capture.capture_response import CaptureResponse
-from ingenico.connect.sdk.domain.errors.error_response import ErrorResponse
-from ingenico.connect.sdk.domain.refund.refund_error_response import RefundErrorResponse
-from ingenico.connect.sdk.domain.refund.refund_response import RefundResponse
-
-
-class CapturesClient(ApiResource):
-    """
-    Captures 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(CapturesClient, self).__init__(parent, path_context)
-
-    def get(self, capture_id, context=None):
-        """
-        Resource /{merchantId}/captures/{captureId} - Get capture
-        
-        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/captures/get.html
-
-        :param capture_id:  str
-        :param context:     :class:`ingenico.connect.sdk.call_context.CallContext`
-        :return: :class:`ingenico.connect.sdk.domain.capture.capture_response.CaptureResponse`
-        :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 = {
-            "captureId": capture_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/captures/{captureId}", path_context)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    None,
-                    CaptureResponse,
-                    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 refund(self, capture_id, body, context=None):
-        """
-        Resource /{merchantId}/captures/{captureId}/refund - Create Refund
-        
-        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/captures/refund.html
-
-        :param capture_id:  str
-        :param body:        :class:`ingenico.connect.sdk.domain.refund.refund_request.RefundRequest`
-        :param context:     :class:`ingenico.connect.sdk.call_context.CallContext`
-        :return: :class:`ingenico.connect.sdk.domain.refund.refund_response.RefundResponse`
-        :raise: DeclinedRefundException if the Ingenico ePayments platform declined / rejected the refund. The refund result will be available from the exception.
-        :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 = {
-            "captureId": capture_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/captures/{captureId}/refund", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    RefundResponse,
-                    context)
-
-        except ResponseException as e:
-            error_type = RefundErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)

connect-sdk-python2-3.45.0/ingenico/connect/sdk/merchant/disputes/__init__.py

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