onlinepayments-sdk-python3 4.22.0__zip → 5.0.0__zip

{onlinepayments-sdk-python3-4.22.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/log/communicator_logger.py

@@ -1,4 +1,8 @@
 from abc import ABC, abstractmethod
+from typing import Optional
+
+from .request_log_message import RequestLogMessage
+from .response_log_message import ResponseLogMessage
 
 
 class CommunicatorLogger(ABC):
@@ -6,14 +10,14 @@ class CommunicatorLogger(ABC):
     Used to log messages from communicators.
     """
 
-    def log_request(self, request_log_message):
+    def log_request(self, request_log_message: RequestLogMessage) -> None:
         """
         Logs a request message object
 
         """
         self.log(request_log_message.get_message())
 
-    def log_response(self, response_log_message):
+    def log_response(self, response_log_message: ResponseLogMessage) -> None:
         """
         Logs a response message object
 
@@ -21,10 +25,11 @@ class CommunicatorLogger(ABC):
         self.log(response_log_message.get_message())
 
     @abstractmethod
-    def log(self, message, thrown=None):
+    def log(self, message: str, thrown: Optional[Exception] = None) -> None:
         """
         Logs a throwable with an accompanying message.
 
         :param message: The message accompanying the throwable.
         :param thrown: The throwable to log.
         """
+        raise NotImplementedError

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/log/header_obfuscator.py

@@ -0,0 +1,49 @@
+from typing import Dict, Mapping, Optional
+
+from .obfuscation_rule import ObfuscationRule, obfuscate_with_fixed_length
+
+
+class HeaderObfuscator(object):
+    """
+    A class that can be used to obfuscate headers.
+    """
+
+    __obfuscation_rules: Dict[str, ObfuscationRule] = None
+
+    def __init__(self, additional_rules: Optional[Mapping[str, ObfuscationRule]] = 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 = {
+                        "X-GCS-Authentication-Token": obfuscate_with_fixed_length(8),
+            "X-GCS-CallerPassword": obfuscate_with_fixed_length(8),
+            "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),
+        }
+        if additional_rules:
+            for name, rule in additional_rules.items():
+                name = name.lower()
+                self.__obfuscation_rules[name] = rule
+
+    def obfuscate_header(self, header_name: str, value: str) -> str:
+        """
+        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() -> 'HeaderObfuscator':
+        return _DEFAULT_HEADER_OBFUSCATOR
+
+
+_DEFAULT_HEADER_OBFUSCATOR = HeaderObfuscator()

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/log/log_message.py

@@ -0,0 +1,94 @@
+from abc import ABC, abstractmethod
+from typing import List, Optional, Sequence, Tuple, Union
+
+from .body_obfuscator import BodyObfuscator
+from .header_obfuscator import HeaderObfuscator
+
+
+class LogMessage(ABC):
+    """
+    A utility class to build log messages.
+    """
+    __request_id: str = None
+    __headers: str = None
+    __body: Optional[str] = None
+    __content_type: Optional[str] = None
+    __header_list: List[Tuple[str, str]] = None
+    __body_obfuscator: BodyObfuscator = None
+    __header_obfuscator: HeaderObfuscator = None
+
+    def __init__(self, request_id: str,
+                 body_obfuscator: BodyObfuscator = BodyObfuscator.default_body_obfuscator(),
+                 header_obfuscator: HeaderObfuscator = 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) -> str:
+        return self.__request_id
+
+    @property
+    def headers(self) -> str:
+        return str(self.__headers)
+
+    @property
+    def body(self) -> Optional[str]:
+        return self.__body
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.__content_type
+
+    def add_header(self, name: str, value: Optional[str]) -> None:
+        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: Union[str, bytes, None], content_type: Optional[str], charset: Optional[str] = None) -> 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: Optional[str]) -> None:
+        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: Optional[str]) -> bool:
+        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)
+
+    @staticmethod
+    def empty_if_none(value: Optional[str]) -> str:
+        if value is not None:
+            return value
+        return ""
+
+    @abstractmethod
+    def get_message(self) -> str:
+        raise NotImplementedError
+
+    def get_header_list(self) -> Sequence[Tuple[str, str]]:
+        return self.__header_list

{onlinepayments-sdk-python3-4.22.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/log/logging_capable.py

@@ -1,5 +1,7 @@
 from abc import ABC, abstractmethod
 
+from .communicator_logger import CommunicatorLogger
+
 
 class LoggingCapable(ABC):
     """
@@ -8,15 +10,17 @@ class LoggingCapable(ABC):
     """
 
     @abstractmethod
-    def enable_logging(self, communicator_logger):
+    def enable_logging(self, communicator_logger: CommunicatorLogger) -> None:
         """
         Turns on logging using the given communicator logger.
 
-        :raise: ValueError If the given communicator logger is None.
+        :raise ValueError: If the given communicator logger is None.
         """
+        raise NotImplementedError
 
     @abstractmethod
-    def disable_logging(self):
+    def disable_logging(self) -> None:
         """
         Turns off logging.
         """
+        raise NotImplementedError

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/log/obfuscation_capable.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+
+from .body_obfuscator import BodyObfuscator
+from .header_obfuscator import HeaderObfuscator
+
+
+class ObfuscationCapable(ABC):
+    """
+    Classes that extend this class support obfuscating bodies and headers.
+    """
+
+    @abstractmethod
+    def set_body_obfuscator(self, body_obfuscator: BodyObfuscator) -> None:
+        """
+        Sets the current body obfuscator to use.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_header_obfuscator(self, header_obfuscator: HeaderObfuscator) -> None:
+        """
+        Sets the current header obfuscator to use.
+        """
+        raise NotImplementedError

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/log/obfuscation_rule.py

@@ -0,0 +1,50 @@
+from typing import Callable
+
+
+ObfuscationRule = Callable[[str], str]
+
+
+def obfuscate_all() -> ObfuscationRule:
+    """
+    Returns an obfuscation rule (function) that will replace all characters with *
+    """
+    return lambda value: '*' * len(value) if value else value
+
+
+def obfuscate_with_fixed_length(fixed_length: int) -> ObfuscationRule:
+    """
+    Returns an obfuscation rule (function) that will replace values with a fixed length string containing only *
+    """
+    return lambda value: '*' * fixed_length
+
+
+def obfuscate_all_but_first(count: int) -> ObfuscationRule:
+    """
+    Returns an obfuscation rule (function) that will keep a fixed number of characters at the start,
+    then replaces all other characters with *
+    """
+    def obfuscate_value(value: str) -> str:
+        if not value:
+            return value
+        length = len(value)
+        if length < count:
+            return value
+        end = '*' * (length - count)
+        return value[:count] + end
+    return obfuscate_value
+
+
+def obfuscate_all_but_last(count: int) -> ObfuscationRule:
+    """
+    Returns an obfuscation rule that will keep a fixed number of characters at the end,
+    then replaces all other characters with *
+    """
+    def obfuscate_value(value: str) -> str:
+        if not value:
+            return value
+        length = len(value)
+        if length < count:
+            return value
+        start = '*' * (length - count)
+        return start + value[-count:]
+    return obfuscate_value

{onlinepayments-sdk-python3-4.22.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/log/python_communicator_logger.py

@@ -1,4 +1,7 @@
-from onlinepayments.sdk.log.communicator_logger import CommunicatorLogger
+from logging import Logger
+from typing import Optional
+
+from .communicator_logger import CommunicatorLogger
 
 
 class PythonCommunicatorLogger(CommunicatorLogger):
@@ -6,7 +9,7 @@ class PythonCommunicatorLogger(CommunicatorLogger):
     A communicator logger that is backed by the log library.
     """
 
-    def __init__(self, logger, log_level, error_log_level=False):
+    def __init__(self, logger: Logger, log_level: int, error_log_level: Optional[int] = None):
         """
         Logs messages to the argument logger using the argument log_level.
         If absent, the error_log_level will be equal to the log_level.
@@ -34,7 +37,7 @@ class PythonCommunicatorLogger(CommunicatorLogger):
         self.__log_level = log_level
         self.__error_log_level = error_log_level
 
-    def log(self, message, thrown=None):
+    def log(self, message: str, thrown: Optional[Exception] = None) -> None:
         """
         Log a message to the underlying logger.
         If thrown is absent, the message will be logged with the

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/log/request_log_message.py

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

{onlinepayments-sdk-python3-4.22.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/log/response_log_message.py

@@ -1,4 +1,6 @@
-from onlinepayments.sdk.log.log_message import LogMessage
+from .body_obfuscator import BodyObfuscator
+from .header_obfuscator import HeaderObfuscator
+from .log_message import LogMessage
 
 
 class ResponseLogMessage(LogMessage):
@@ -6,21 +8,20 @@ class ResponseLogMessage(LogMessage):
     A utility class to build request log messages.
     """
 
-    def __init__(self, request_id, status_code, duration=-1):
-        super(ResponseLogMessage, self).__init__(request_id)
+    def __init__(self, request_id: str, status_code: int, duration: int = -1,
+                 body_obfuscator: BodyObfuscator = BodyObfuscator.default_body_obfuscator(),
+                 header_obfuscator: HeaderObfuscator = HeaderObfuscator.default_header_obfuscator()):
+        super(ResponseLogMessage, self).__init__(request_id, body_obfuscator, header_obfuscator)
         self.__status_code = status_code
-        if duration is False:
-            self.__duration = -1
-        else:
-            self.__duration = duration
+        self.__duration = duration
 
-    def get_duration(self):
+    def get_duration(self) -> int:
         return self.__duration
 
-    def get_status_code(self):
+    def get_status_code(self) -> int:
         return self.__status_code
 
-    def get_message(self):
+    def get_message(self) -> str:
         if self.__duration < 0:
             return "Incoming response (requestId='" + self.request_id + "'):\n" + \
                    "  status_code:  " + str(self.__status_code) + "\n" + \

{onlinepayments-sdk-python3-4.22.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/log/sys_out_communicator_logger.py

@@ -1,7 +1,8 @@
 from datetime import datetime
 from threading import Lock
+from typing import Optional
 
-from onlinepayments.sdk.log.python_communicator_logger import CommunicatorLogger
+from .communicator_logger import CommunicatorLogger
 
 
 class SysOutCommunicatorLogger(CommunicatorLogger):
@@ -10,27 +11,25 @@ class SysOutCommunicatorLogger(CommunicatorLogger):
     It includes a timestamp in yyyy-MM-ddTHH:mm:ss format in the system time zone.
     """
 
-    def __init__(self):
-        CommunicatorLogger.__init__(self)
-
     _global_lock = Lock()
     _old_print = print
 
     @staticmethod
-    def INSTANCE():
+    def instance() -> 'SysOutCommunicatorLogger':
         return _SYS_OUT_COMMUNICATOR_LOGGER_INSTANCE
 
-    def __print(self, *a):
+    def __print(self, *a) -> None:
         with self._global_lock:
             self._old_print(*a)
 
-    def log(self, message, thrown=None):
+    def log(self, message: str, thrown: Optional[Exception] = None) -> None:
         # Make sure the same object is used for locking and printing
         self.__print(self.__get_date_prefix() + message)
         if thrown:
             self.__print(str(thrown))
 
-    def __get_date_prefix(self):
+    @staticmethod
+    def __get_date_prefix() -> str:
         return datetime.now().strftime("%Y-%m-%dT%H:%M:%S ")
 
 

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/merchant/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/merchant/captures/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/merchant/captures/captures_client.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Mapping, Optional
+
+from .i_captures_client import ICapturesClient
+
+from onlinepayments.sdk.api_resource import ApiResource
+from onlinepayments.sdk.call_context import CallContext
+from onlinepayments.sdk.communication.response_exception import ResponseException
+from onlinepayments.sdk.domain.captures_response import CapturesResponse
+from onlinepayments.sdk.domain.error_response import ErrorResponse
+from onlinepayments.sdk.exception_factory import create_exception
+
+
+class CapturesClient(ApiResource, ICapturesClient):
+    """
+    Captures client. Thread-safe.
+    """
+
+    def __init__(self, parent: ApiResource, path_context: Optional[Mapping[str, str]]):
+        """
+        :param parent:       :class:`onlinepayments.sdk.api_resource.ApiResource`
+        :param path_context: Mapping[str, str]
+        """
+        super(CapturesClient, self).__init__(parent=parent, path_context=path_context)
+
+    def get_captures(self, payment_id: str, context: Optional[CallContext] = None) -> CapturesResponse:
+        """
+        Resource /v2/{merchantId}/payments/{paymentId}/captures - Get captures of payment
+
+        :param payment_id:  str
+        :param context:     :class:`onlinepayments.sdk.call_context.CallContext`
+        :return: :class:`onlinepayments.sdk.domain.captures_response.CapturesResponse`
+        :raise IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :raise ValidationException: if the request was not correct and couldn't be processed (HTTP status code 400)
+        :raise AuthorizationException: if the request was not allowed (HTTP status code 403)
+        :raise ReferenceException: if an object was attempted to be referenced that doesn't exist or has been removed,
+                   or there was a conflict (HTTP status code 404, 409 or 410)
+        :raise PlatformException: if something went wrong at the payment platform,
+                   the payment platform was unable to process a message from a downstream partner/acquirer,
+                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
+        :raise ApiException: if the payment platform returned any other error
+        """
+        path_context = {
+            "paymentId": payment_id,
+        }
+        uri = self._instantiate_uri("/v2/{merchantId}/payments/{paymentId}/captures", path_context)
+        try:
+            return self._communicator.get(
+                    uri,
+                    self._client_headers,
+                    None,
+                    CapturesResponse,
+                    context)
+
+        except ResponseException as e:
+            error_type = ErrorResponse
+            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
+            raise create_exception(e.status_code, e.body, error_object, context)

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/merchant/captures/i_captures_client.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from onlinepayments.sdk.call_context import CallContext
+from onlinepayments.sdk.domain.captures_response import CapturesResponse
+
+
+class ICapturesClient(ABC):
+    """
+    Captures client interface. Thread-safe.
+    """
+
+    @abstractmethod
+    def get_captures(self, payment_id: str, context: Optional[CallContext] = None) -> CapturesResponse:
+        """
+        Resource /v2/{merchantId}/payments/{paymentId}/captures - Get captures of payment
+
+        :param payment_id:  str
+        :param context:     :class:`onlinepayments.sdk.call_context.CallContext`
+        :return: :class:`onlinepayments.sdk.domain.captures_response.CapturesResponse`
+        :raise IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :raise ValidationException: if the request was not correct and couldn't be processed (HTTP status code 400)
+        :raise AuthorizationException: if the request was not allowed (HTTP status code 403)
+        :raise ReferenceException: if an object was attempted to be referenced that doesn't exist or has been removed,
+                   or there was a conflict (HTTP status code 404, 409 or 410)
+        :raise PlatformException: if something went wrong at the payment platform,
+                   the payment platform was unable to process a message from a downstream partner/acquirer,
+                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
+        :raise ApiException: if the payment platform returned any other error
+        """

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/merchant/complete/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/merchant/complete/complete_client.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Mapping, Optional
+
+from .i_complete_client import ICompleteClient
+
+from onlinepayments.sdk.api_resource import ApiResource
+from onlinepayments.sdk.call_context import CallContext
+from onlinepayments.sdk.communication.response_exception import ResponseException
+from onlinepayments.sdk.domain.complete_payment_request import CompletePaymentRequest
+from onlinepayments.sdk.domain.complete_payment_response import CompletePaymentResponse
+from onlinepayments.sdk.domain.payment_error_response import PaymentErrorResponse
+from onlinepayments.sdk.exception_factory import create_exception
+
+
+class CompleteClient(ApiResource, ICompleteClient):
+    """
+    Complete client. Thread-safe.
+    """
+
+    def __init__(self, parent: ApiResource, path_context: Optional[Mapping[str, str]]):
+        """
+        :param parent:       :class:`onlinepayments.sdk.api_resource.ApiResource`
+        :param path_context: Mapping[str, str]
+        """
+        super(CompleteClient, self).__init__(parent=parent, path_context=path_context)
+
+    def complete_payment(self, payment_id: str, body: CompletePaymentRequest, context: Optional[CallContext] = None) -> CompletePaymentResponse:
+        """
+        Resource /v2/{merchantId}/payments/{paymentId}/complete - Complete payment
+
+        :param payment_id:  str
+        :param body:        :class:`onlinepayments.sdk.domain.complete_payment_request.CompletePaymentRequest`
+        :param context:     :class:`onlinepayments.sdk.call_context.CallContext`
+        :return: :class:`onlinepayments.sdk.domain.complete_payment_response.CompletePaymentResponse`
+        :raise DeclinedPaymentException: if the payment platform declined / rejected the payment. The payment result will be available from the exception.
+        :raise IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :raise ValidationException: if the request was not correct and couldn't be processed (HTTP status code 400)
+        :raise AuthorizationException: if the request was not allowed (HTTP status code 403)
+        :raise ReferenceException: if an object was attempted to be referenced that doesn't exist or has been removed,
+                   or there was a conflict (HTTP status code 404, 409 or 410)
+        :raise PlatformException: if something went wrong at the payment platform,
+                   the payment platform was unable to process a message from a downstream partner/acquirer,
+                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
+        :raise ApiException: if the payment platform returned any other error
+        """
+        path_context = {
+            "paymentId": payment_id,
+        }
+        uri = self._instantiate_uri("/v2/{merchantId}/payments/{paymentId}/complete", path_context)
+        try:
+            return self._communicator.post(
+                    uri,
+                    self._client_headers,
+                    None,
+                    body,
+                    CompletePaymentResponse,
+                    context)
+
+        except ResponseException as e:
+            error_type = PaymentErrorResponse
+            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
+            raise create_exception(e.status_code, e.body, error_object, context)

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/merchant/complete/i_complete_client.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from onlinepayments.sdk.call_context import CallContext
+from onlinepayments.sdk.domain.complete_payment_request import CompletePaymentRequest
+from onlinepayments.sdk.domain.complete_payment_response import CompletePaymentResponse
+
+
+class ICompleteClient(ABC):
+    """
+    Complete client interface. Thread-safe.
+    """
+
+    @abstractmethod
+    def complete_payment(self, payment_id: str, body: CompletePaymentRequest, context: Optional[CallContext] = None) -> CompletePaymentResponse:
+        """
+        Resource /v2/{merchantId}/payments/{paymentId}/complete - Complete payment
+
+        :param payment_id:  str
+        :param body:        :class:`onlinepayments.sdk.domain.complete_payment_request.CompletePaymentRequest`
+        :param context:     :class:`onlinepayments.sdk.call_context.CallContext`
+        :return: :class:`onlinepayments.sdk.domain.complete_payment_response.CompletePaymentResponse`
+        :raise DeclinedPaymentException: if the payment platform declined / rejected the payment. The payment result will be available from the exception.
+        :raise IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :raise ValidationException: if the request was not correct and couldn't be processed (HTTP status code 400)
+        :raise AuthorizationException: if the request was not allowed (HTTP status code 403)
+        :raise ReferenceException: if an object was attempted to be referenced that doesn't exist or has been removed,
+                   or there was a conflict (HTTP status code 404, 409 or 410)
+        :raise PlatformException: if something went wrong at the payment platform,
+                   the payment platform was unable to process a message from a downstream partner/acquirer,
+                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
+        :raise ApiException: if the payment platform returned any other error
+        """

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/merchant/hostedcheckout/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#