connect-sdk-python2 3.47.0__zip → 4.0.1__zip

connect-sdk-python2-3.47.0/ingenico/connect/sdk/endpoint_configuration.py

@@ -1,173 +0,0 @@
-from ConfigParser import NoOptionError
-from urlparse import urlparse
-
-from proxy_configuration import ProxyConfiguration
-from ingenico.connect.sdk.domain.metadata.shopping_cart_extension import ShoppingCartExtension
-
-
-class EndpointConfiguration(object):
-    """
-    Base class for endpoint configurations.
-    """
-    # The default number of maximum connections.
-    DEFAULT_MAX_CONNECTIONS = 10
-
-    def __init__(self, properties=None, prefix=None):
-        if properties and properties.sections() and properties.options("ConnectSDK"):
-            self.__endpoint = self.__get_endpoint(properties, prefix)
-            self.__connect_timeout = int(properties.get("ConnectSDK", prefix + ".connectTimeout"))
-            self.__socket_timeout = int(properties.get("ConnectSDK", prefix + ".socketTimeout"))
-            self.__max_connections = self.__get_property(properties, prefix + ".maxConnections", self.DEFAULT_MAX_CONNECTIONS)
-            try:
-                proxy_uri = properties.get("ConnectSDK", prefix + ".proxy.uri")
-            except NoOptionError:
-                proxy_uri = None
-            try:
-                proxy_user = properties.get("ConnectSDK", prefix + ".proxy.username")
-            except NoOptionError:
-                proxy_user = None
-            try:
-                proxy_pass = properties.get("ConnectSDK", prefix + ".proxy.password")
-            except NoOptionError:
-                proxy_pass = None
-            if proxy_uri is not None:
-                self.__proxy_configuration = ProxyConfiguration.from_uri(proxy_uri, proxy_user, proxy_pass)
-            else:
-                self.__proxy_configuration = None
-            try:
-                self.__integrator = properties.get("ConnectSDK", prefix + ".integrator")
-            except NoOptionError:
-                self.__integrator = None
-            try:
-                self.__shopping_cart_extension = self.__get_shopping_cart_extension(properties, prefix)
-            except NoOptionError:
-                self.__shopping_cart_extension = None
-
-    @staticmethod
-    def __get_property(properties, key, default_value):
-        try:
-            property_value = properties.get("ConnectSDK", key)
-        except NoOptionError:
-            property_value = None
-        if property_value is not None:
-            return int(property_value)
-        else:
-            return default_value
-
-    def __get_endpoint(self, properties, prefix):
-        host = properties.get("ConnectSDK", prefix + ".endpoint.host")
-        try:
-            scheme = properties.get("ConnectSDK", prefix + ".endpoint.scheme")
-        except NoOptionError:
-            scheme = None
-        try:
-            port = properties.get("ConnectSDK", prefix + ".endpoint.port")
-        except NoOptionError:
-            port = None
-        if scheme:
-            if port:
-                return self.__create_uri(scheme, host, int(port))
-            else:
-                return self.__create_uri(scheme, host, -1)
-        elif port:
-            return self.__create_uri("https", host, int(port))
-        else:
-            return self.__create_uri("https", host, -1)
-
-    @staticmethod
-    def __create_uri(scheme, host, port):
-        if port != -1:
-            uri = scheme + "://" + host + ":" + str(port)
-        else:
-            uri = scheme + "://" + host
-        url = urlparse(uri)
-        if not url.scheme.lower() in ["http", "https"] or not url.netloc:
-            raise ValueError("Unable to construct endpoint URI")
-        return url
-
-    @staticmethod
-    def __get_shopping_cart_extension(properties, prefix):
-        try:
-            creator = properties.get("ConnectSDK", prefix + ".shoppingCartExtension.creator")
-        except NoOptionError:
-            creator = None
-        try:
-            name = properties.get("ConnectSDK", prefix + ".shoppingCartExtension.name")
-        except NoOptionError:
-            name = None
-        try:
-            version = properties.get("ConnectSDK", prefix + ".shoppingCartExtension.version")
-        except NoOptionError:
-            version = None
-        try:
-            extension_id = properties.get("ConnectSDK", prefix + ".shoppingCartExtension.extensionId")
-        except NoOptionError:
-            extension_id = None
-        if creator is None and name is None and version is None and extension_id is None:
-            return None
-        else:
-            return ShoppingCartExtension(creator, name, version, extension_id)
-
-    @property
-    def _endpoint(self):
-        return self.__endpoint
-
-    def _set_endpoint(self, endpoint):
-        if isinstance(endpoint, basestring):
-            endpoint = urlparse(str(endpoint))
-        if endpoint is not None and endpoint.path:
-            raise ValueError("apiEndpoint should not contain a path")
-        if endpoint is not None and \
-                (endpoint.username is not None or endpoint.query or endpoint.fragment):
-            raise ValueError("apiEndpoint should not contain user info, query or fragment")
-        self.__endpoint = endpoint
-
-    @property
-    def connect_timeout(self):
-        """Connection timeout for the underlying network communication in seconds"""
-        return self.__connect_timeout
-
-    @connect_timeout.setter
-    def connect_timeout(self, connect_timeout):
-        self.__connect_timeout = connect_timeout
-
-    @property
-    def socket_timeout(self):
-        """Socket timeout for the underlying network communication in seconds"""
-        return self.__socket_timeout
-
-    @socket_timeout.setter
-    def socket_timeout(self, socket_timeout):
-        self.__socket_timeout = socket_timeout
-
-    @property
-    def max_connections(self):
-        return self.__max_connections
-
-    @max_connections.setter
-    def max_connections(self, max_connections):
-        self.__max_connections = max_connections
-
-    @property
-    def proxy_configuration(self):
-        return self.__proxy_configuration
-
-    @proxy_configuration.setter
-    def proxy_configuration(self, proxy_configuration):
-        self.__proxy_configuration = proxy_configuration
-
-    @property
-    def integrator(self):
-        return self.__integrator
-
-    @integrator.setter
-    def integrator(self, integrator):
-        self.__integrator = integrator
-
-    @property
-    def shopping_cart_extension(self):
-        return self.__shopping_cart_extension
-
-    @shopping_cart_extension.setter
-    def shopping_cart_extension(self, shopping_cart_extension):
-        self.__shopping_cart_extension = shopping_cart_extension

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

@@ -1,130 +0,0 @@
-from ConfigParser import ConfigParser
-
-from communicator import Communicator
-from communicator_configuration import CommunicatorConfiguration
-from client import Client
-from meta_data_provider import MetaDataProvider
-from session import Session
-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
-
-
-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.47.0/ingenico/connect/sdk/global_collect_exception.py

@@ -1,12 +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.47.0/ingenico/connect/sdk/idempotence_exception.py

@@ -1,29 +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.47.0/ingenico/connect/sdk/log/body_obfuscator.py

@@ -1,98 +0,0 @@
-import codecs
-import re
-
-from obfuscation_rule import obfuscate_all, obfuscate_with_fixed_length, obfuscate_all_but_first, obfuscate_all_but_last
-
-
-class BodyObfuscator(object):
-    """
-    A class that can be used to obfuscate properties in JSON bodies.
-    """
-
-    __obfuscation_rules = None
-    __parameter_names = None
-
-    def __init__(self, additional_rules=None):
-        """
-        Creates a new  body obfuscator.
-        This will contain some pre-defined obfuscation rules, as well as any provided custom rules
-
-        :param additional_rules: An optional mapping from property names to obfuscation rules,
-         where an obfuscation rule is a function that obfuscates a single string,
-        """
-        self.__obfuscation_rules = {
-            "cardNumber": obfuscate_all_but_last(4),
-            "expiryDate": obfuscate_all_but_last(2),
-            "cvv": obfuscate_all(),
-            "iban": obfuscate_all_but_last(4),
-            "accountNumber": obfuscate_all_but_last(4),
-            "reformattedAccountNumber": obfuscate_all_but_last(4),
-            "bin": obfuscate_all_but_first(6),
-            "value": obfuscate_all(),
-            "keyId": obfuscate_with_fixed_length(8),
-            "secretKey": obfuscate_with_fixed_length(8),
-            "publicKey": obfuscate_with_fixed_length(8),
-            "userAuthenticationToken": obfuscate_with_fixed_length(8),
-            "encryptedPayload": obfuscate_with_fixed_length(8),
-            "decryptedPayload": obfuscate_with_fixed_length(8),
-            "encryptedCustomerInput": obfuscate_with_fixed_length(8),
-        }
-        if additional_rules:
-            for name, rule in additional_rules.iteritems():
-                self.__obfuscation_rules[name] = rule
-
-        self.__parameter_names = tuple(self.__obfuscation_rules.keys())
-
-    @staticmethod
-    def __build_property_pattern(property_names):
-        if not property_names:
-            return re.compile("$^")
-        s = "([\"'])("
-        for p in property_names:
-            s += '|' + re.escape(p)
-        s += ")\\1\\s*:\\s*(?:([\"'])(.*?)(?<!\\\\)\\3|([^\"'\\s\\[\\{]((?!,)\\S)*))"
-        return re.compile(s, re.DOTALL)
-
-    def __obfuscate_value(self, property_name, value):
-        obfuscation_rule = self.__obfuscation_rules.get(property_name)
-        if obfuscation_rule:
-            return obfuscation_rule(value)
-        return value
-
-    def obfuscate_body(self, body, charset=None):
-        """
-        Obfuscates the body from the given stream as necessary.
-        :param body: The body to obfuscate, as string or bytes.
-        :param charset: The charset to use to read the body bytes.
-        """
-        if charset:
-            body = codecs.decode(body, charset)
-
-        if body is None:
-            return None
-        if not body:
-            return ""
-        index = 0
-        s_obfuscate = ""
-        pattern = self.__build_property_pattern(self.__parameter_names)
-        matcher = pattern.finditer(body)
-        for x in matcher:
-            property_name = x.group(2)
-            value = x.group(4)
-            value_start = x.start(4)
-            value_end = x.end(4)
-            if not value:
-                value = x.group(5)
-                value_start = x.start(5)
-                value_end = x.end(5)
-            obfuscated_value = self.__obfuscate_value(property_name, value)
-            s_obfuscate += body[index:value_start] + obfuscated_value
-            index = value_end
-        return s_obfuscate + body[index:]
-
-    @staticmethod
-    def default_body_obfuscator():
-        return _DEFAULT_BODY_OBFUSCATOR
-
-
-_DEFAULT_BODY_OBFUSCATOR = BodyObfuscator()

connect-sdk-python2-3.47.0/ingenico/connect/sdk/log/communicator_logger.py

@@ -1,30 +0,0 @@
-class CommunicatorLogger:
-    """
-    Used to log messages from communicators.
-    """
-
-    def __init__(self):
-        pass
-
-    def log_request(self, request_log_message):
-        """
-        Logs a request message object
-
-        """
-        self.log(request_log_message.get_message())
-
-    def log_response(self, response_log_message):
-        """
-        Logs a response message object
-
-        """
-        self.log(response_log_message.get_message())
-
-    def log(self, message, thrown=None):
-        """
-        Logs a throwable with an accompanying message.
-
-        :param message: The message accompanying the throwable.
-        :param thrown: The throwable to log.
-        """
-        raise NotImplementedError

connect-sdk-python2-3.47.0/ingenico/connect/sdk/log/header_obfuscator.py

@@ -1,47 +0,0 @@
-from obfuscation_rule import obfuscate_with_fixed_length
-
-
-class HeaderObfuscator:
-    """
-    A class that can be used to obfuscate headers.
-    """
-
-    __obfuscation_rules = None
-
-    def __init__(self, additional_rules=None):
-        """
-        Creates a new  header obfuscator.
-        This will contain some pre-defined obfuscation rules, as well as any provided custom rules
-
-        :param additional_rules: An optional mapping from property names to obfuscation rules,
-         where an obfuscation rule is a function that obfuscates a single string,
-        """
-        self.__obfuscation_rules = {
-            "authorization": obfuscate_with_fixed_length(8),
-            "www-authenticate": obfuscate_with_fixed_length(8),
-            "proxy-authenticate": obfuscate_with_fixed_length(8),
-            "proxy-authorization": obfuscate_with_fixed_length(8),
-            "x-gcs-authentication-token": obfuscate_with_fixed_length(8),
-            "x-gcs-callerpassword": obfuscate_with_fixed_length(8),
-        }
-        if additional_rules:
-            for name, rule in additional_rules.iteritems():
-                name = name.lower()
-                self.__obfuscation_rules[name] = rule
-
-    def obfuscate_header(self, header_name, value):
-        """
-        Obfuscates the value for the given header as necessary.
-        """
-        header_name = header_name.lower()
-        obfuscation_rule = self.__obfuscation_rules.get(header_name)
-        if obfuscation_rule:
-            return obfuscation_rule(value)
-        return value
-
-    @staticmethod
-    def default_header_obfuscator():
-        return _DEFAULT_HEADER_OBFUSCATOR
-
-
-_DEFAULT_HEADER_OBFUSCATOR = HeaderObfuscator()

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

@@ -1,89 +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>"
-
-    @staticmethod
-    def __is_binary(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.47.0/ingenico/connect/sdk/log/logging_capable.py

@@ -1,19 +0,0 @@
-class LoggingCapable(object):
-    """
-    Classes that extend this class have support for log messages from
-    communicators.
-    """
-
-    def enable_logging(self, communicator_logger):
-        """
-        Turns on logging using the given communicator logger.
-
-        :raise: ValueError If the given communicator logger is None.
-        """
-        raise NotImplementedError
-
-    def disable_logging(self):
-        """
-        Turns off logging.
-        """
-        raise NotImplementedError

connect-sdk-python2-3.47.0/ingenico/connect/sdk/log/logging_util.py

@@ -1,32 +0,0 @@
-from body_obfuscator import BodyObfuscator
-from header_obfuscator import HeaderObfuscator
-
-
-class LoggingUtil:
-    """
-    A utility class to support logging.
-    """
-
-    def __init__(self):
-        pass
-
-    @staticmethod
-    def obfuscate_body(body, charset=None):
-        """
-        Obfuscates the body from the given stream as necessary.
-
-        Deprecated; Use BodyObfuscator instead
-
-        :param body: The body to obfuscate, as string or bytes
-        :param charset: The charset to use to read the body input stream.
-        """
-        return BodyObfuscator.default_body_obfuscator().obfuscate_body(body, charset)
-
-    @staticmethod
-    def obfuscate_header(name, value):
-        """
-        Obfuscates the value for the given header as necessary.
-
-        Deprecated; Use HeaderObfuscator instead
-        """
-        return HeaderObfuscator.default_header_obfuscator().obfuscate_header(name, value)