connect-sdk-python2 3.47.0__zip → 4.0.1__zip

connect-sdk-python2-4.0.1/worldline/connect/sdk/authentication/authenticator.py

@@ -0,0 +1,20 @@
+from abc import ABCMeta, abstractmethod
+
+
+class Authenticator(object):
+    """
+    Used to authenticate requests to the Worldline Global Collect platform.
+    """
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def get_authorization(self, http_method, resource_uri, request_headers):
+        """
+        Returns a value that can be used for the "Authorization" header.
+
+        :param http_method: The HTTP method.
+        :param resource_uri: The URI of the resource.
+        :param request_headers: A sequence of RequestHeaders.
+         This sequence may not be modified and may not contain headers with the same name.
+        """
+        raise NotImplementedError

connect-sdk-python2-4.0.1/worldline/connect/sdk/authentication/authorization_type.py

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

connect-sdk-python2-4.0.1/worldline/connect/sdk/authentication/v1hmac_authenticator.py

@@ -0,0 +1,103 @@
+import hashlib
+import hmac
+from base64 import b64encode
+from operator import attrgetter
+from re import sub
+
+from authenticator import Authenticator
+
+from worldline.connect.sdk.communication.request_header import RequestHeader
+
+
+class V1HMACAuthenticator(Authenticator):
+    """
+    Authenticator implementation using v1HMAC signatures.
+    """
+
+    def __init__(self, api_key_id, secret_api_key):
+        """
+        :param api_key_id: An identifier for the secret API key. The api_key_id
+         can be retrieved from the Configuration Center. This identifier is
+         visible in the HTTP request and is also used to identify the correct
+         account.
+        :param secret_api_key: A shared secret. The shared secret can be
+         retrieved from the Configuration Center. An api_key_id and
+         secret_api_key always go hand-in-hand, the difference is that
+         secret_api_key is never visible in the HTTP request. This secret is
+         used as input for the HMAC algorithm.
+        """
+        Authenticator.__init__(self)
+        if secret_api_key is None or not secret_api_key.strip():
+            raise ValueError("secret_api_key is required")
+        if api_key_id is None or not api_key_id.strip():
+            raise ValueError("api_key_id is required")
+        self.__api_key_id = api_key_id
+        self.__secret_api_key = secret_api_key
+
+    def get_authorization(self, http_method, resource_uri, http_headers):
+        """Returns a v1HMAC authentication signature header"""
+        if http_method is None or not http_method.strip():
+            raise ValueError("http_method is required")
+        if resource_uri is None:
+            raise ValueError("resource_uri is required")
+        data_to_sign = self.to_data_to_sign(http_method, resource_uri, http_headers)
+        return "GCS v1HMAC:" + self.__api_key_id + ":" + self.create_authentication_signature(data_to_sign)
+
+    def to_data_to_sign(self, http_method, resource_uri, http_headers):
+        content_type = None
+        date = None
+        canonicalized_headers = ""
+        canonicalized_resource = self.__to_canonicalized_resource(resource_uri)
+        xgcs_http_headers = []
+        if http_headers is not None:
+            for http_header in http_headers:
+                if "Content-Type".lower() == http_header.name.lower():
+                    content_type = http_header.value
+                elif "Date".lower() == http_header.name.lower():
+                    date = http_header.value
+                else:
+                    name = self.__to_canonicalize_header_name(http_header.name)
+                    if name.startswith("x-gcs"):
+                        value = self.to_canonicalize_header_value(http_header.value)
+                        xgcs_http_header = RequestHeader(name, value)
+                        xgcs_http_headers.append(xgcs_http_header)
+        xgcs_http_headers.sort(key=attrgetter('name'))
+        for xgcs_http_header in xgcs_http_headers:
+            canonicalized_headers += xgcs_http_header.name + ":" + xgcs_http_header.value + "\n"
+        string = http_method.upper() + "\n"
+        if content_type is not None:
+            string += content_type + "\n"
+        else:
+            string += "\n"
+        string += date + "\n"
+        string += str(canonicalized_headers)
+        string += canonicalized_resource + "\n"
+        return str(string)
+
+    @staticmethod
+    def __to_canonicalized_resource(resource_uri):
+        """
+        Returns the encoded URI path without the HTTP method and including all decoded query parameters.
+        """
+        string = ""
+        string += resource_uri.path
+        if resource_uri.query:
+            string += "?" + resource_uri.query
+        return str(string)
+
+    @staticmethod
+    def __to_canonicalize_header_name(original_name):
+        if original_name is None:
+            return None
+        else:
+            return original_name.lower()
+
+    @staticmethod
+    def to_canonicalize_header_value(original_value):
+        if original_value is None:
+            return ""
+        return sub(r"\r?\n(?:(?![\r\n])\s)*", " ", original_value).strip()
+
+    def create_authentication_signature(self, data_to_sign):
+        sig = hmac.new(self.__secret_api_key, data_to_sign, hashlib.sha256)
+        return b64encode(sig.digest())

connect-sdk-python2-4.0.1/worldline/connect/sdk/call_context.py

@@ -0,0 +1,39 @@
+class CallContext(object):
+    """
+    A call context can be used to send extra information with a request, and to receive extra information from a response.
+    
+    Please note that this class is not thread-safe. Each request should get its own call context instance.
+    """
+    __idempotence_key = None
+    __idempotence_request_timestamp = None
+
+    def __init__(self, idempotence_key=None):
+        """
+        Sets the idempotence key to use for the next request for which this call context is used.
+        """
+        self.__idempotence_key = idempotence_key
+
+    @property
+    def idempotence_key(self):
+        """
+        :return: The idempotence key.
+        """
+        return self.__idempotence_key
+
+    @property
+    def idempotence_request_timestamp(self):
+        """
+        :return: The idempotence request timestamp from the response to the last
+         request for which this call context was used, or None if no idempotence
+         request timestamp was present.
+        """
+        return self.__idempotence_request_timestamp
+
+    @idempotence_request_timestamp.setter
+    def idempotence_request_timestamp(self, idempotence_request_timestamp):
+        """
+        Sets the idempotence request timestamp.
+        This method should only be called by Communicator objects based on the
+        response to the request for which this call context was used.
+        """
+        self.__idempotence_request_timestamp = idempotence_request_timestamp

connect-sdk-python2-4.0.1/worldline/connect/sdk/client.py

@@ -0,0 +1,92 @@
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from base64 import b64encode
+
+from api_resource import ApiResource
+
+from worldline.connect.sdk.log.logging_capable import LoggingCapable
+from worldline.connect.sdk.log.obfuscation_capable import ObfuscationCapable
+from worldline.connect.sdk.v1.v1_client import V1Client
+
+
+class Client(ApiResource, LoggingCapable, ObfuscationCapable):
+    """
+    Worldline Global Collect platform client.
+
+    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.
+    """
+
+    def __init__(self, communicator, client_meta_info=None):
+        """
+        :param communicator:      :class:`worldline.connect.sdk.communicator.Communicator`
+        :param client_meta_info:  str
+        """
+        super(Client, self).__init__(communicator=communicator,
+                                     client_meta_info=client_meta_info)
+
+    def with_client_meta_info(self, client_meta_info):
+        """
+        :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
+        """
+        if self._client_meta_info is None and client_meta_info is None:
+            return self
+        if client_meta_info is None:
+            return Client(self._communicator, None)
+        # Checking to see if this is valid JSON (no JSON parse exceptions)
+        self._communicator.marshaller.unmarshal(client_meta_info, object)
+        client_meta_info = b64encode(client_meta_info.encode('utf-8'))
+        if client_meta_info == self._client_meta_info:
+            return self
+        return Client(self._communicator, client_meta_info)
+
+    def close_idle_connections(self, idle_time):
+        """
+        Utility method that delegates the call to this client's communicator.
+
+        :param idle_time: a datetime.timedelta object indicating the idle time
+        """
+        self._communicator.close_idle_connections(idle_time)
+
+    def close_expired_connections(self):
+        """
+        Utility method that delegates the call to this client's communicator.
+        """
+        self._communicator.close_expired_connections()
+
+    def set_body_obfuscator(self, body_obfuscator):
+        # delegate to the communicator
+        self._communicator.set_body_obfuscator(body_obfuscator)
+
+    def set_header_obfuscator(self, header_obfuscator):
+        # delegate to the communicator
+        self._communicator.set_header_obfuscator(header_obfuscator)
+
+    def enable_logging(self, communicator_logger):
+        # delegate to the communicator
+        self._communicator.enable_logging(communicator_logger)
+
+    def disable_logging(self):
+        # delegate to the communicator
+        self._communicator.disable_logging()
+
+    def close(self):
+        """
+        Releases any system resources associated with this object.
+        """
+        self._communicator.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def v1(self):
+        return V1Client(self, None)

connect-sdk-python2-4.0.1/worldline/connect/sdk/communication/communication_exception.py

@@ -0,0 +1,8 @@
+class CommunicationException(RuntimeError):
+    """
+    Indicates an exception regarding the communication with the Worldline Global Collect platform such as a connection exception.
+    """
+
+    def __init__(self, exception):
+        super(CommunicationException, self).__init__(exception)
+        self.cause = exception

connect-sdk-python2-4.0.1/worldline/connect/sdk/communication/connection.py

@@ -0,0 +1,75 @@
+from abc import ABCMeta, abstractmethod
+
+from worldline.connect.sdk.log.logging_capable import LoggingCapable
+from worldline.connect.sdk.log.obfuscation_capable import ObfuscationCapable
+
+
+class Connection(LoggingCapable, ObfuscationCapable):
+    """
+    Represents a connection to the Worldline Global Collect platform server.
+    """
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def get(self, url, request_headers):
+        """
+        Send a GET request to the Worldline Global Collect platform and return the response.
+
+        :param url: The URI to call, including any necessary query parameters.
+        :param request_headers: An optional sequence of request headers.
+        :return: The response from the Worldline Global Collect platform as a tuple with
+         the status code, headers and a generator of body chunks
+        :raise CommunicationException: when an exception occurred communicating
+         with the Worldline Global Collect platform
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete(self, url, request_headers):
+        """
+        Send a DELETE request to the Worldline Global Collect platform and return the response.
+
+        :param url: The URI to call, including any necessary query parameters.
+        :param request_headers: An optional sequence of request headers.
+        :return: The response from the Worldline Global Collect platform as a tuple with
+         the status code, headers and a generator of body chunks
+        :raise CommunicationException: when an exception occurred communicating
+         with the Worldline Global Collect platform
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def post(self, url, request_headers, body):
+        """
+        Send a POST request to the Worldline Global Collect platform and return the response.
+
+        :param url: The URI to call, including any necessary query parameters.
+        :param request_headers: An optional sequence of request headers.
+        :param body: The optional body to send.
+        :return: The response from the Worldline Global Collect platform as a tuple with
+         the status code, headers and a generator of body chunks
+        :raise CommunicationException: when an exception occurred communicating
+         with the Worldline Global Collect platform
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def put(self, url, request_headers, body):
+        """
+        Send a PUT request to the Worldline Global Collect platform and return the response.
+
+        :param url: The URI to call, including any necessary query parameters.
+        :param request_headers: An optional sequence of request headers.
+        :param body: The optional body to send.
+        :return: The response from the Worldline Global Collect platform as a tuple with
+         the status code, headers and a generator of body chunks
+        :raise CommunicationException: when an exception occurred communicating
+         with the Worldline Global Collect platform
+        """
+        raise NotImplementedError
+
+    def close(self):
+        """
+        Releases any system resources associated with this object.
+        """
+        pass

connect-sdk-python2-4.0.1/worldline/connect/sdk/communication/default_connection.py

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