connect-sdk-python3 3.46.0__zip → 4.0.0__zip

connect-sdk-python3-4.0.0/worldline/connect/sdk/log/body_obfuscator.py

@@ -0,0 +1,100 @@
+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 = {
+            "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()

connect-sdk-python3-4.0.0/worldline/connect/sdk/log/communicator_logger.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from .request_log_message import RequestLogMessage
+from .response_log_message import ResponseLogMessage
+
+
+class CommunicatorLogger(ABC):
+    """
+    Used to log messages from communicators.
+    """
+
+    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: ResponseLogMessage) -> None:
+        """
+        Logs a response message object
+
+        """
+        self.log(response_log_message.get_message())
+
+    @abstractmethod
+    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

connect-sdk-python3-4.0.0/worldline/connect/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 = {
+            "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),
+            "x-gcs-authentication-token": obfuscate_with_fixed_length(8),
+            "x-gcs-callerpassword": 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()

connect-sdk-python3-4.0.0/worldline/connect/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

connect-sdk-python3-4.0.0/worldline/connect/sdk/log/logging_capable.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+
+from .communicator_logger import CommunicatorLogger
+
+
+class LoggingCapable(ABC):
+    """
+    Classes that extend this class have support for log messages from
+    communicators.
+    """
+
+    @abstractmethod
+    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 NotImplementedError
+
+    @abstractmethod
+    def disable_logging(self) -> None:
+        """
+        Turns off logging.
+        """
+        raise NotImplementedError

connect-sdk-python3-4.0.0/worldline/connect/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

connect-sdk-python3-4.0.0/worldline/connect/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

connect-sdk-python3-4.0.0/worldline/connect/sdk/log/python_communicator_logger.py

@@ -0,0 +1,54 @@
+from logging import Logger
+from typing import Optional
+
+from .communicator_logger import CommunicatorLogger
+
+
+class PythonCommunicatorLogger(CommunicatorLogger):
+    """
+    A communicator logger that is backed by the log library.
+    """
+
+    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.
+        Note that if the CommunicatorLogger's log level is lower than the
+        argument logger's log level (e.g. the CommunicatorLogger is given
+        log.INFO as level and the argument logger has a level of
+        log.WARNING), then nothing will be logged to the logger.
+
+        :param logger: the logger to log to
+        :param log_level: the log level that will be used for non-error
+         messages logged via the CommunicatorLogger
+        :param error_log_level: the log level that will be used for error
+         messages logged via the CommunicatorLogger.
+        """
+        CommunicatorLogger.__init__(self)
+        if not error_log_level:
+            error_log_level = log_level
+        if logger is None:
+            raise ValueError("logger is required")
+        if log_level is None:
+            raise ValueError("log_level is required")
+        if error_log_level is None:
+            raise ValueError("error_log_level is required")
+        self.__logger = logger
+        self.__log_level = log_level
+        self.__error_log_level = error_log_level
+
+    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
+        CommunicatorLogger's log_level, if a thrown object is provided,
+        the message and exception will be logged with the CommunicatorLogger's
+        error_log_level.
+
+        :param message: the message to be logged
+        :param thrown: an optional throwable object
+        """
+        if not thrown:
+            self.__logger.log(self.__log_level, message)
+        else:
+            self.__logger.log(self.__error_log_level, message, thrown)

connect-sdk-python3-4.0.0/worldline/connect/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 + "'"

connect-sdk-python3-4.0.0/worldline/connect/sdk/log/response_log_message.py

@@ -0,0 +1,37 @@
+from .body_obfuscator import BodyObfuscator
+from .header_obfuscator import HeaderObfuscator
+from .log_message import LogMessage
+
+
+class ResponseLogMessage(LogMessage):
+    """
+    A utility class to build request log messages.
+    """
+
+    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
+        self.__duration = duration
+
+    def get_duration(self) -> int:
+        return self.__duration
+
+    def get_status_code(self) -> int:
+        return self.__status_code
+
+    def get_message(self) -> str:
+        if self.__duration < 0:
+            return "Incoming response (requestId='" + self.request_id + "'):\n" + \
+                   "  status_code:  " + str(self.__status_code) + "\n" + \
+                   "  headers:      " + self.headers + "\n" + \
+                   "  content-type: " + self.empty_if_none(self.content_type) + "\n" + \
+                   "  body:         " + self.empty_if_none(self.body)
+
+        else:
+            return "Incoming response (requestId='" + self.request_id + "', " + str(self.__duration) + " ms):\n" + \
+                   "  status_code:  " + str(self.__status_code) + "\n" + \
+                   "  headers:      " + self.headers + "\n" + \
+                   "  content-type: " + self.empty_if_none(self.content_type) + "\n" + \
+                   "  body:         " + self.empty_if_none(self.body)

connect-sdk-python3-4.0.0/worldline/connect/sdk/log/sys_out_communicator_logger.py

@@ -0,0 +1,36 @@
+from datetime import datetime
+from threading import Lock
+from typing import Optional
+
+from .communicator_logger import CommunicatorLogger
+
+
+class SysOutCommunicatorLogger(CommunicatorLogger):
+    """
+    A communicator logger that prints its message to sys.stdout
+    It includes a timestamp in yyyy-MM-ddTHH:mm:ss format in the system time zone.
+    """
+
+    _global_lock = Lock()
+    _old_print = print
+
+    @staticmethod
+    def instance() -> 'SysOutCommunicatorLogger':
+        return _SYS_OUT_COMMUNICATOR_LOGGER_INSTANCE
+
+    def __print(self, *a) -> None:
+        with self._global_lock:
+            self._old_print(*a)
+
+    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))
+
+    @staticmethod
+    def __get_date_prefix() -> str:
+        return datetime.now().strftime("%Y-%m-%dT%H:%M:%S ")
+
+
+_SYS_OUT_COMMUNICATOR_LOGGER_INSTANCE = SysOutCommunicatorLogger()

connect-sdk-python3-4.0.0/worldline/connect/sdk/proxy_configuration.py

@@ -0,0 +1,102 @@
+from typing import Optional
+from urllib.parse import urlparse
+
+
+class ProxyConfiguration(object):
+    """
+    HTTP proxy configuration.
+
+    Can be initialised directly from a host and port or can be constructed from a uri using fromuri
+    """
+
+    def __init__(self, host: str, port: int, scheme: str = "http", username: Optional[str] = None, password: Optional[str] = None):
+        if not host:
+            raise ValueError("host is required")
+        if not port:
+            raise ValueError("port is required")
+        if port <= 0 or port > 65535:
+            raise ValueError("""port "{}" is invalid""".format(port))
+        self.__scheme = scheme
+        self.__host = host
+        self.__port = port
+        self.__username = username
+        self.__password = password
+
+    @staticmethod
+    def from_uri(uri: str, username: Optional[str] = None, password: Optional[str] = None) -> 'ProxyConfiguration':
+        """
+        Constructs a ProxyConfiguration from a URI; if username and/or password
+        are given they will be used instead of corresponding data in the URI
+        """
+        parsed = urlparse(uri)
+        scheme = parsed.scheme
+        host = parsed.hostname + parsed.path
+        port = parsed.port
+        if username is None:
+            username = parsed.username
+        if password is None:
+            password = parsed.password
+        if port is None:
+            if scheme == "http":
+                port = 80
+            elif scheme == "https":
+                port = 443
+            else:
+                raise ValueError("unsupported scheme: " + scheme)
+        return ProxyConfiguration(scheme=scheme,
+                                  host=host,
+                                  port=port,
+                                  username=username,
+                                  password=password)
+
+    @property
+    def scheme(self) -> str:
+        return self.__scheme
+
+    @scheme.setter
+    def scheme(self, scheme: str) -> None:
+        self.__scheme = scheme
+
+    @property
+    def host(self) -> str:
+        return self.__host
+
+    @host.setter
+    def host(self, host: str) -> None:
+        self.__host = host
+
+    @property
+    def port(self) -> int:
+        return self.__port
+
+    @port.setter
+    def port(self, port: int) -> None:
+        self.__port = port
+
+    @property
+    def username(self) -> Optional[str]:
+        return self.__username
+
+    @username.setter
+    def username(self, username: Optional[str]) -> None:
+        self.__username = username
+
+    @property
+    def password(self) -> Optional[str]:
+        return self.__password
+
+    @password.setter
+    def password(self, password: Optional[str]) -> None:
+        self.__password = password
+
+    def __str__(self):
+        """
+        Return a proxy string in the form scheme://username:password@host:port
+        or scheme://host:port if authentication is absent
+
+        Supports HTTP Basic Auth
+        """
+        if self.username is None or self.password is None:
+            return r"{0}://{1}:{2}".format(self.scheme, self.host, self.port)
+        else:
+            return r"{0}://{3}:{4}@{1}:{2}".format(self.scheme, self.host, self.port, self.username, self.password)

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/__init__.py

@@ -0,0 +1,4 @@
+#
+# This file was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com
+#