connect-sdk-python3 3.47.0__zip → 4.0.1__zip

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

@@ -0,0 +1,301 @@
+import math
+import uuid
+from datetime import datetime, timedelta
+from typing import Mapping, Optional, Sequence
+from urllib.parse import urlparse
+
+import requests
+from requests.adapters import HTTPAdapter
+from requests.models import PreparedRequest
+from requests.exceptions import RequestException, Timeout
+from requests_toolbelt import MultipartEncoder
+
+from .communication_exception import CommunicationException
+from .connection import RequestBody, Response, URI
+from .multipart_form_data_object import MultipartFormDataObject
+from .pooled_connection import PooledConnection
+from .request_header import RequestHeader
+from .response_header import get_header_value
+
+from worldline.connect.sdk.communicator_configuration import CommunicatorConfiguration
+from worldline.connect.sdk.proxy_configuration import ProxyConfiguration
+from worldline.connect.sdk.log.body_obfuscator import BodyObfuscator
+from worldline.connect.sdk.log.communicator_logger import CommunicatorLogger
+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: int, socket_timeout: int,
+                 max_connections: int = CommunicatorConfiguration.DEFAULT_MAX_CONNECTIONS,
+                 proxy_configuration: Optional[ProxyConfiguration] = 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) -> Optional[int]:
+        """Connection timeout in seconds"""
+        return self.__connect_timeout
+
+    @property
+    def socket_timeout(self) -> Optional[int]:
+        """Socket timeout in seconds"""
+        return self.__socket_timeout
+
+    def get(self, url: URI, request_headers: Sequence[RequestHeader]) -> Response:
+        """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: URI, request_headers: Sequence[RequestHeader]) -> Response:
+        """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: URI, request_headers: Sequence[RequestHeader], body: RequestBody) -> Response:
+        """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: URI, request_headers: Sequence[RequestHeader], body: RequestBody) -> Response:
+        """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: MultipartFormDataObject) -> MultipartEncoder:
+        fields = {}
+        for name, value in multipart.values.items():
+            fields[name] = value
+        for name, uploadable_file in multipart.files.items():
+            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: str, url: URI, headers: Sequence[RequestHeader], body: RequestBody = None) -> Response:
+        """
+        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, str):
+            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: PreparedRequest) -> None:
+        """
+        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: requests.models.Response, **kwargs) -> None:
+        """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 = 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: str, error: Exception, start_time: datetime) -> None:
+        """Log communication errors when logging is enabled"""
+        logger = self.logger
+        if logger:
+            duration = 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: Mapping[str, str]) -> bool:
+        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: BodyObfuscator) -> None:
+        self.__body_obfuscator = body_obfuscator
+
+    def set_header_obfuscator(self, header_obfuscator: HeaderObfuscator) -> None:
+        self.__header_obfuscator = header_obfuscator
+
+    def enable_logging(self, communicator_logger: CommunicatorLogger) -> None:
+        self.logger = communicator_logger
+
+    def disable_logging(self) -> None:
+        self.logger = None
+
+    def close_idle_connections(self, idle_time: timedelta) -> None:
+        """
+        :param idle_time: a datetime.timedelta object indicating the idle time
+        """
+        pass
+
+    def close_expired_connections(self) -> None:
+        pass
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self) -> None:
+        """
+        Explicitly closes the connection
+        """
+        self.__requests_session.close()

connect-sdk-python3-4.0.1/worldline/connect/sdk/communication/metadata_provider.py

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

connect-sdk-python3-4.0.1/worldline/connect/sdk/communication/multipart_form_data_object.py

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

connect-sdk-python3-4.0.1/worldline/connect/sdk/communication/multipart_form_data_request.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+
+from .multipart_form_data_object import MultipartFormDataObject
+
+
+class MultipartFormDataRequest(ABC):
+    """
+    A representation of a multipart/form-data request.
+    """
+
+    @abstractmethod
+    def to_multipart_form_data_object(self) -> MultipartFormDataObject:
+        """
+        :return: :class:`worldline.connect.sdk.communication.MultipartFormDataObject`
+        """
+        raise NotImplementedError

connect-sdk-python3-4.0.1/worldline/connect/sdk/communication/not_found_exception.py

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

connect-sdk-python3-4.0.1/worldline/connect/sdk/communication/param_request.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+from typing import List
+
+from .request_param import RequestParam
+
+
+class ParamRequest(ABC):
+    """
+    Represents a set of request parameters.
+    """
+
+    @abstractmethod
+    def to_request_parameters(self) -> List[RequestParam]:
+        """
+        :return: list[:class:`worldline.connect.sdk.communication.RequestParam`] representing the HTTP request parameters
+        """
+        raise NotImplementedError

connect-sdk-python3-4.0.1/worldline/connect/sdk/communication/pooled_connection.py

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

connect-sdk-python3-4.0.1/worldline/connect/sdk/communication/request_header.py

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

connect-sdk-python3-4.0.1/worldline/connect/sdk/communication/request_param.py

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