onlinepayments-sdk-python3 4.23.0__zip → 5.0.0__zip

{onlinepayments-sdk-python3-4.23.0/onlinepayments/sdk/defaultimpl → onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/json}/default_marshaller.py

@@ -1,8 +1,10 @@
 from json import dumps, loads
+from typing import Any, Type, Union
 
-from onlinepayments.sdk.data_object import DataObject
-from onlinepayments.sdk.marshaller import Marshaller
-from onlinepayments.sdk.marshaller_syntax_exception import MarshallerSyntaxException
+from .marshaller import Marshaller, T
+from .marshaller_syntax_exception import MarshallerSyntaxException
+
+from onlinepayments.sdk.domain.data_object import DataObject
 
 
 class DefaultMarshaller(Marshaller):
@@ -11,27 +13,30 @@ class DefaultMarshaller(Marshaller):
     """
 
     @staticmethod
-    def INSTANCE():
+    def instance() -> 'DefaultMarshaller':
         return _DEFAULT_MARSHALLER_INSTANCE
 
-    def marshal(self, request_object):
+    def marshal(self, request_object: Any) -> str:
         if isinstance(request_object, DataObject):
             dictionary = request_object.to_dictionary()
-            return dumps(dictionary, default=lambda o: o.to_dictionary(),
+            return dumps(dictionary,
+                         default=lambda o: o.to_dictionary(),
                          indent=4)
         else:
-            return dumps(request_object, default=lambda o: o.__dict__, indent=4)
+            return dumps(request_object,
+                         default=lambda o: o.__dict__,
+                         indent=4)
 
-    def unmarshal(self, response_json, type_class):
+    def unmarshal(self, response_json: Union[str, bytes, None], type_class: Type[T]) -> T:
         if not response_json:
             return None
         if issubclass(type_class, DataObject):
             try:
                 return type_class().from_dictionary(loads(response_json))
             except ValueError as e:
-                raise MarshallerSyntaxException(e)
+                raise MarshallerSyntaxException(e) from e
 
-        class Object:
+        class Object(object):
             pass
 
         def convert_to_object(d):
@@ -49,7 +54,7 @@ class DefaultMarshaller(Marshaller):
             converted_object = convert_to_object(dictionary)
             return converted_object
         except ValueError as e:
-            raise MarshallerSyntaxException(e)
+            raise MarshallerSyntaxException(e) from e
 
 
 _DEFAULT_MARSHALLER_INSTANCE = DefaultMarshaller()

{onlinepayments-sdk-python3-4.23.0/onlinepayments/sdk → onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/json}/marshaller.py

@@ -1,27 +1,32 @@
 from abc import ABC, abstractmethod
+from typing import Any, Optional, Type, TypeVar, Union
+
+
+T = TypeVar('T')
 
 
 class Marshaller(ABC):
     """
-    Used to marshal and unmarshal Online Payments platform request and response
-    objects to and from JSON.
+    Used to marshal and unmarshal Online Payments platform request and response objects to and from JSON.
     """
 
     @abstractmethod
-    def marshal(self, request_object):
+    def marshal(self, request_object: Any) -> str:
         """
         Marshal a request object to a JSON string.
 
         :param request_object: the object to marshal into a serialized JSON string
         :return: the serialized JSON string of the request_object
         """
+        raise NotImplementedError
 
     @abstractmethod
-    def unmarshal(self, response_json, type_class):
+    def unmarshal(self, response_json: Union[str, bytes, None], type_class: Type[T]) -> Optional[T]:
         """
         Unmarshal a JSON string to a response object.
 
         :param response_json: the json body that should be unmarshalled
         :param type_class: The class to which the response_json should be unmarshalled
-        :raise: MarshallerSyntaxException if the JSON is not a valid representation for an object of the given type
+        :raise MarshallerSyntaxException: if the JSON is not a valid representation for an object of the given type
         """
+        raise NotImplementedError

{onlinepayments-sdk-python3-4.23.0/onlinepayments/sdk → onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/json}/marshaller_syntax_exception.py

@@ -1,9 +1,12 @@
+from typing import Optional
+
+
 class MarshallerSyntaxException(RuntimeError):
     """
     Thrown when a JSON string cannot be converted to a response object.
     """
 
-    def __init__(self, cause=False):
+    def __init__(self, cause: Optional[Exception] = None):
         if cause:
             super(MarshallerSyntaxException, self).__init__(cause)
         else:

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

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

{onlinepayments-sdk-python3-4.23.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.23.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.23.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.23.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.23.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.
+#