onlinepayments-sdk-python3 4.23.0__zip → 5.1.0__zip

onlinepayments_sdk_python3-5.1.0/onlinepayments/sdk/client.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from base64 import b64encode
+from datetime import timedelta
+from typing import Optional
+
+from .api_resource import ApiResource
+from .i_client import IClient
+from .i_communicator import ICommunicator
+
+from onlinepayments.sdk.log.body_obfuscator import BodyObfuscator
+from onlinepayments.sdk.log.communicator_logger import CommunicatorLogger
+from onlinepayments.sdk.log.header_obfuscator import HeaderObfuscator
+from onlinepayments.sdk.merchant.i_merchant_client import IMerchantClient
+from onlinepayments.sdk.merchant.merchant_client import MerchantClient
+
+
+class Client(ApiResource, IClient):
+    """
+    Payment 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: ICommunicator, client_meta_info: Optional[str] = None):
+        """
+        :param communicator:      :class:`onlinepayments.sdk.i_communicator.ICommunicator`
+        :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: Optional[str]) -> 'Client':
+        """
+        :param client_meta_info: JSON string containing the metadata for the client
+        :return: a new Client which uses the passed metadata for the X-GCS-ClientMetaInfo header.
+        :raise MarshallerSyntaxException: if the given clientMetaInfo is not a valid JSON string
+        """
+        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')).decode('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: timedelta) -> None:
+        """
+        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) -> None:
+        """
+        Utility method that delegates the call to this client's communicator.
+        """
+        self._communicator.close_expired_connections()
+
+    def set_body_obfuscator(self, body_obfuscator: BodyObfuscator) -> None:
+        # delegate to the communicator
+        self._communicator.set_body_obfuscator(body_obfuscator)
+
+    def set_header_obfuscator(self, header_obfuscator: HeaderObfuscator) -> None:
+        # delegate to the communicator
+        self._communicator.set_header_obfuscator(header_obfuscator)
+
+    def enable_logging(self, communicator_logger: CommunicatorLogger) -> None:
+        # delegate to the communicator
+        self._communicator.enable_logging(communicator_logger)
+
+    def disable_logging(self) -> None:
+        # delegate to the communicator
+        self._communicator.disable_logging()
+
+    def close(self) -> None:
+        """
+        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 merchant(self, merchant_id: str) -> IMerchantClient:
+        """
+        Resource /v2/{merchantId}
+
+        :param merchant_id:  str
+        :return: :class:`onlinepayments.sdk.merchant.i_merchant_client.IMerchantClient`
+        """
+        sub_context = {
+            "merchantId": merchant_id,
+        }
+        return MerchantClient(self, sub_context)

{onlinepayments-sdk-python3-4.23.0/onlinepayments/sdk → onlinepayments_sdk_python3-5.1.0/onlinepayments/sdk/communication}/communication_exception.py

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

{onlinepayments-sdk-python3-4.23.0/onlinepayments/sdk → onlinepayments_sdk_python3-5.1.0/onlinepayments/sdk/communication}/connection.py

@@ -1,70 +1,84 @@
 from abc import ABC, abstractmethod
+from typing import Iterable, Mapping, Sequence, Tuple, Union
+from urllib.parse import ParseResult
+
+from .multipart_form_data_object import MultipartFormDataObject
+from .request_header import RequestHeader
 
 from onlinepayments.sdk.log.logging_capable import LoggingCapable
+from onlinepayments.sdk.log.obfuscation_capable import ObfuscationCapable
+
 
+URI = Union[str, ParseResult]
+RequestBody = Union[str, MultipartFormDataObject, None]
+Response = Tuple[int, Mapping[str, str], Iterable[bytes]]
 
-# noinspection PyAbstractClass
-class Connection(LoggingCapable, ABC):
+
+class Connection(LoggingCapable, ObfuscationCapable, ABC):
     """
     Represents a connection to the Online Payments platform server.
     """
 
     @abstractmethod
-    def get(self, url, request_headers):
+    def get(self, url: URI, request_headers: Sequence[RequestHeader]) -> Response:
         """
         Send a GET request to the Online Payments platform and return the response.
 
         :param url: The URI to call, including any necessary query parameters.
-        :param request_headers: An optional list of request headers.
+        :param request_headers: An optional sequence of request headers.
         :return: The response from the Online Payments platform as a tuple with
          the status code, headers and a generator of body chunks
-        :raise: CommunicationException when an exception occurred communicating
+        :raise CommunicationException: when an exception occurred communicating
          with the Online Payments platform
         """
+        raise NotImplementedError
 
     @abstractmethod
-    def delete(self, url, request_headers):
+    def delete(self, url: URI, request_headers: Sequence[RequestHeader]) -> Response:
         """
         Send a DELETE request to the Online Payments platform and return the response.
 
         :param url: The URI to call, including any necessary query parameters.
-        :param request_headers: An optional list of request headers.
+        :param request_headers: An optional sequence of request headers.
         :return: The response from the Online Payments platform as a tuple with
          the status code, headers and a generator of body chunks
-        :raise: CommunicationException when an exception occurred communicating
+        :raise CommunicationException: when an exception occurred communicating
          with the Online Payments platform
         """
+        raise NotImplementedError
 
     @abstractmethod
-    def post(self, url, request_headers, body):
+    def post(self, url: URI, request_headers: Sequence[RequestHeader], body: RequestBody) -> Response:
         """
         Send a POST request to the Online Payments platform and return the response.
 
         :param url: The URI to call, including any necessary query parameters.
-        :param request_headers: An optional list of request headers.
+        :param request_headers: An optional sequence of request headers.
         :param body: The optional body to send.
         :return: The response from the Online Payments platform as a tuple with
          the status code, headers and a generator of body chunks
-        :raise: CommunicationException when an exception occurred communicating
+        :raise CommunicationException: when an exception occurred communicating
          with the Online Payments platform
         """
+        raise NotImplementedError
 
     @abstractmethod
-    def put(self, url, request_headers, body):
+    def put(self, url: URI, request_headers: Sequence[RequestHeader], body: RequestBody) -> Response:
         """
         Send a PUT request to the Online Payments platform and return the response.
 
         :param url: The URI to call, including any necessary query parameters.
-        :param request_headers: An optional list of request headers.
+        :param request_headers: An optional sequence of request headers.
         :param body: The optional body to send.
         :return: The response from the Online Payments platform as a tuple with
          the status code, headers and a generator of body chunks
-        :raise: CommunicationException when an exception occurred communicating
+        :raise CommunicationException: when an exception occurred communicating
          with the Online Payments platform
         """
+        raise NotImplementedError
 
-    @abstractmethod
-    def close(self):
+    def close(self) -> None:
         """
-        Close the connection
+        Releases any system resources associated with this object.
         """
+        pass

{onlinepayments-sdk-python3-4.23.0/onlinepayments/sdk/defaultimpl → onlinepayments_sdk_python3-5.1.0/onlinepayments/sdk/communication}/default_connection.py

@@ -1,20 +1,29 @@
 import math
 import uuid
-from datetime import datetime
+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 onlinepayments.sdk.communication_exception import CommunicationException
-from onlinepayments.sdk.endpoint_configuration import EndpointConfiguration
+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 onlinepayments.sdk.communicator_configuration import CommunicatorConfiguration
+from onlinepayments.sdk.proxy_configuration import ProxyConfiguration
+from onlinepayments.sdk.log.body_obfuscator import BodyObfuscator
+from onlinepayments.sdk.log.communicator_logger import CommunicatorLogger
+from onlinepayments.sdk.log.header_obfuscator import HeaderObfuscator
 from onlinepayments.sdk.log.request_log_message import RequestLogMessage
 from onlinepayments.sdk.log.response_log_message import ResponseLogMessage
-from onlinepayments.sdk.pooled_connection import PooledConnection
-from onlinepayments.sdk.proxy_configuration import ProxyConfiguration
-from onlinepayments.sdk.multipart_form_data_object import MultipartFormDataObject
 
 CHARSET = "UTF-8"
 
@@ -23,145 +32,137 @@ 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.
+    :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.
+    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 = EndpointConfiguration.DEFAULT_CONNECT_TIMEOUT,
-                 socket_timeout: int = EndpointConfiguration.DEFAULT_SOCKET_TIMEOUT,
-                 max_connections: int = EndpointConfiguration.DEFAULT_MAX_CONNECTIONS,
-                 proxy_configuration: ProxyConfiguration = None):
+    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))
+        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)}
+            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) -> int:
+    def connect_timeout(self) -> Optional[int]:
         """Connection timeout in seconds"""
         return self.__connect_timeout
 
     @property
-    def socket_timeout(self) -> int:
+    def socket_timeout(self) -> Optional[int]:
         """Socket timeout in seconds"""
         return self.__socket_timeout
 
-    def get(self, url, request_headers):
+    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 list containing RequestHeader objects
-         representing the request headers
+        :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):
+    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 list containing RequestHeader objects
-         representing the request headers
+        :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):
+    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 list containing RequestHeader objects
-         representing the request headers
+        :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):
+    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 list containing RequestHeader objects
-         representing the request headers
+        :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)
-    
-    def __to_multipart_encoder(self, multipart):
+
+    @staticmethod
+    def __to_multipart_encoder(multipart: MultipartFormDataObject) -> MultipartEncoder:
         fields = {}
-        for name, value in multipart.values.iteritems():
+        for name, value in multipart.values.items():
             fields[name] = value
-        for name, uploadable_file in multipart.files.iteritems():
+        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)
+        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:
+    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):
+    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 list containing RequestHeader objects representing
-         the request headers
+        :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 list of RequestParam objects to a dictionary of key:value
-        # pairs if necessary
+        # 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}
 
-        # generate random uuid for traceability
-        _id = str(uuid.uuid4())
-
-        # set X-Request-Id for better traceability
-        headers['X-Request-Id'] = _id;
-
-        # send request with all parameters not declared in session and with
-        # callback for logging response
-        request = requests.Request(method, url, headers=headers, data=body,
+        # 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()
-        # store random id in request so it can be matched with its response
-        # in logging
+        _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:
@@ -183,11 +184,11 @@ class DefaultConnection(PooledConnection):
         except RequestException as exception:
             self._log_error(prepped_request.id, exception, prepped_request.timestamp)
             raise CommunicationException(exception)
-        except RuntimeError as exception:
+        except Exception as exception:
             self._log_error(prepped_request.id, exception, prepped_request.timestamp)
             raise
 
-    def _log_request(self, request):
+    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
@@ -202,7 +203,11 @@ class DefaultConnection(PooledConnection):
         else:
             local_path = url.path
         try:
-            message = RequestLogMessage(request.id, method, local_path)
+            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
@@ -214,10 +219,9 @@ class DefaultConnection(PooledConnection):
                     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)
+            logger.log("An error occurred trying to log request '{}'".format(request.id), exception)
 
-    def _cb_log_response(self, response, **kwargs):
+    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:
@@ -227,43 +231,61 @@ class DefaultConnection(PooledConnection):
         duration = math.ceil((datetime.now() - request.timestamp).total_seconds() * 1000)
         status_code = response.status_code
         try:
-            message = ResponseLogMessage(_id, status_code, duration)
+            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])
-            # 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 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:
-            message = "An error occurred trying to log response '{}'".format(_id)
-            logger.log(message, exception)
+            logger.log("An error occurred trying to log response '{}'".format(_id), exception)
 
-    def _log_error(self, request_id, error, start_time):
+    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)
+            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):
+    def enable_logging(self, communicator_logger: CommunicatorLogger) -> None:
         self.logger = communicator_logger
 
-    def disable_logging(self):
+    def disable_logging(self) -> None:
         self.logger = None
 
-    def close_idle_connections(self, idle_time):
+    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):
+    def close_expired_connections(self) -> None:
         pass
 
     def __enter__(self):
@@ -272,7 +294,7 @@ class DefaultConnection(PooledConnection):
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
-    def close(self):
+    def close(self) -> None:
         """
         Explicitly closes the connection
         """

onlinepayments_sdk_python3-5.1.0/onlinepayments/sdk/communication/i_metadata_provider.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+from typing import Sequence
+
+from onlinepayments.sdk.communication.request_header import RequestHeader
+
+
+class IMetadataProvider(ABC):
+    """
+    Provides meta info about the server.
+    """
+
+    @property
+    @abstractmethod
+    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.
+        """