onlinepayments-sdk-python3 4.22.0__zip → 5.0.0__zip

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/factory.py

@@ -0,0 +1,127 @@
+from configparser import ConfigParser
+from typing import Optional, Union
+
+from .client import Client
+from .i_client import IClient
+from .communicator import Communicator
+from .i_communicator import ICommunicator
+from .communicator_configuration import CommunicatorConfiguration
+
+from onlinepayments.sdk.authentication.authorization_type import AuthorizationType
+from onlinepayments.sdk.authentication.authenticator import Authenticator
+from onlinepayments.sdk.authentication.v1hmac_authenticator import V1HmacAuthenticator
+from onlinepayments.sdk.communication.connection import Connection
+from onlinepayments.sdk.communication.default_connection import DefaultConnection
+from onlinepayments.sdk.communication.metadata_provider import MetadataProvider
+from onlinepayments.sdk.communication.i_metadata_provider import IMetadataProvider
+from onlinepayments.sdk.json.default_marshaller import DefaultMarshaller
+from onlinepayments.sdk.json.marshaller import Marshaller
+
+
+class Factory(object):
+    """
+    Online Payments platform factory for several SDK components.
+    """
+
+    @staticmethod
+    def create_configuration(configuration_file_name: Union[str, bytes], api_key_id: str, secret_api_key: str) -> CommunicatorConfiguration:
+        """
+        Creates a CommunicatorConfiguration based on the configuration values in configuration_file_name, api_key_id and secret_api_key.
+        """
+        try:
+            parser = ConfigParser()
+            with open(configuration_file_name) as f:
+                parser.read_file(f)
+            return CommunicatorConfiguration(properties=parser,
+                                             api_key_id=api_key_id,
+                                             secret_api_key=secret_api_key)
+        except IOError as e:
+            raise RuntimeError("Unable to read configuration located at {}".format(e.filename), e) from e
+
+    @staticmethod
+    def create_communicator_from_configuration(communicator_configuration: CommunicatorConfiguration,
+                                               metadata_provider: Optional[IMetadataProvider] = None,
+                                               connection: Optional[Connection] = None,
+                                               authenticator: Optional[Authenticator] = None,
+                                               marshaller: Optional[Marshaller] = None) -> ICommunicator:
+        """
+        Creates a Communicator based on the configuration stored in the CommunicatorConfiguration argument
+        """
+        if metadata_provider is None:
+            metadata_provider = MetadataProvider(integrator=communicator_configuration.integrator,
+                                                 shopping_cart_extension=communicator_configuration.shopping_cart_extension)
+        if connection is None:
+            connection = DefaultConnection(communicator_configuration.connect_timeout,
+                                           communicator_configuration.socket_timeout,
+                                           communicator_configuration.max_connections,
+                                           communicator_configuration.proxy_configuration)
+        if authenticator is None:
+            authenticator = Factory.__get_authenticator(communicator_configuration)
+        if marshaller is None:
+            marshaller = DefaultMarshaller.instance()
+        return Communicator(api_endpoint=communicator_configuration.api_endpoint,
+                            metadata_provider=metadata_provider,
+                            connection=connection,
+                            authenticator=authenticator,
+                            marshaller=marshaller)
+
+    @staticmethod
+    def __get_authenticator(communicator_configuration: CommunicatorConfiguration) -> Authenticator:
+        if communicator_configuration.authorization_type == AuthorizationType.V1HMAC:
+            return V1HmacAuthenticator(communicator_configuration)
+        raise RuntimeError("Unknown authorizationType " + communicator_configuration.authorization_type)
+
+    @staticmethod
+    def create_communicator_from_file(configuration_file_name: Union[str, bytes], api_key_id: str, secret_api_key: str,
+                                      metadata_provider: Optional[IMetadataProvider] = None,
+                                      connection: Optional[Connection] = None,
+                                      authenticator: Optional[Authenticator] = None,
+                                      marshaller: Optional[Marshaller] = None) -> ICommunicator:
+        """
+        Creates a Communicator based on the configuration values in configuration_file_name, api_id_key and secret_api_key.
+        """
+        configuration = Factory.create_configuration(configuration_file_name, api_key_id, secret_api_key)
+        return Factory.create_communicator_from_configuration(configuration,
+                                                              metadata_provider=metadata_provider,
+                                                              connection=connection,
+                                                              authenticator=authenticator,
+                                                              marshaller=marshaller)
+
+    @staticmethod
+    def create_client_from_configuration(communicator_configuration: CommunicatorConfiguration,
+                                         metadata_provider: Optional[IMetadataProvider] = None,
+                                         connection: Optional[Connection] = None,
+                                         authenticator: Optional[Authenticator] = None,
+                                         marshaller: Optional[Marshaller] = None) -> IClient:
+        """
+        Create a Client based on the configuration stored in the CommunicatorConfiguration argument
+        """
+        communicator = Factory.create_communicator_from_configuration(communicator_configuration,
+                                                                      metadata_provider=metadata_provider,
+                                                                      connection=connection,
+                                                                      authenticator=authenticator,
+                                                                      marshaller=marshaller)
+        return Client(communicator)
+
+    @staticmethod
+    def create_client_from_communicator(communicator: ICommunicator) -> IClient:
+        """
+        Create a Client based on the settings stored in the Communicator argument
+        """
+        return Client(communicator)
+
+    @staticmethod
+    def create_client_from_file(configuration_file_name: Union[str, bytes], api_key_id: str, secret_api_key: str,
+                                metadata_provider: Optional[IMetadataProvider] = None,
+                                connection: Optional[Connection] = None,
+                                authenticator: Optional[Authenticator] = None,
+                                marshaller: Optional[Marshaller] = None) -> IClient:
+        """
+        Creates a Client based on the configuration values in configuration_file_name, api_key_id and secret_api_key.
+        """
+        communicator = Factory.create_communicator_from_file(configuration_file_name, api_key_id, secret_api_key,
+                                                             metadata_provider=metadata_provider,
+                                                             connection=connection,
+                                                             authenticator=authenticator,
+                                                             marshaller=marshaller)
+        return Client(communicator)

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/i_client.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from abc import abstractmethod
+from datetime import timedelta
+from typing import Optional
+
+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.logging_capable import LoggingCapable
+from onlinepayments.sdk.log.obfuscation_capable import ObfuscationCapable
+from onlinepayments.sdk.merchant.i_merchant_client import IMerchantClient
+
+
+class IClient(LoggingCapable, ObfuscationCapable):
+    """
+    Payment platform client interface.
+
+    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.
+    """
+
+    @abstractmethod
+    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
+        """
+
+    @abstractmethod
+    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
+        """
+
+    @abstractmethod
+    def close_expired_connections(self) -> None:
+        """
+        Utility method that delegates the call to this client's communicator.
+        """
+
+    @abstractmethod
+    def set_body_obfuscator(self, body_obfuscator: BodyObfuscator) -> None:
+        """"""
+
+    @abstractmethod
+    def set_header_obfuscator(self, header_obfuscator: HeaderObfuscator) -> None:
+        """"""
+
+    @abstractmethod
+    def enable_logging(self, communicator_logger: CommunicatorLogger) -> None:
+        """"""
+
+    @abstractmethod
+    def disable_logging(self) -> None:
+        """"""
+
+    @abstractmethod
+    def close(self) -> None:
+        """
+        Releases any system resources associated with this object.
+        """
+
+    @abstractmethod
+    def merchant(self, merchant_id: str) -> IMerchantClient:
+        """
+        Resource /v2/{merchantId}
+
+        :param merchant_id:  str
+        :return: :class:`onlinepayments.sdk.merchant.i_merchant_client.IMerchantClient`
+        """

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/i_communicator.py

@@ -0,0 +1,180 @@
+from abc import abstractmethod
+from typing import List, Optional, Type, Tuple, Mapping, Iterable, Any
+
+from onlinepayments.sdk.call_context import CallContext
+from onlinepayments.sdk.communication.param_request import ParamRequest
+from onlinepayments.sdk.communication.request_header import RequestHeader
+from onlinepayments.sdk.json.marshaller import Marshaller, T
+from onlinepayments.sdk.log.logging_capable import LoggingCapable
+from onlinepayments.sdk.log.obfuscation_capable import ObfuscationCapable
+
+BinaryResponse = Tuple[Mapping[str, str], Iterable[bytes]]
+
+
+class ICommunicator(LoggingCapable, ObfuscationCapable):
+    """
+    Used to communicate with the Online Payments platform web services.
+
+    It contains all the logic to transform a request object to an HTTP request and an HTTP response to a response object.
+    """
+
+    @abstractmethod
+    def close(self) -> None:
+        """
+        Releases any system resources associated with this object.
+        """
+
+    @abstractmethod
+    def get(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+            request_parameters: Optional[ParamRequest],
+            response_type: Type[T],
+            context: Optional[CallContext]) -> T:
+        """
+        Corresponds to the HTTP GET method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param response_type: The type of response to return.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def get_with_binary_response(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+                                 request_parameters: Optional[ParamRequest],
+                                 context: Optional[CallContext]) -> BinaryResponse:
+        """
+        Corresponds to the HTTP GET method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def delete(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+               request_parameters: Optional[ParamRequest],
+               response_type: Type[T],
+               context: Optional[CallContext]) -> T:
+        """
+        Corresponds to the HTTP DELETE method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param response_type: The type of response to return.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def delete_with_binary_response(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+                                    request_parameters: Optional[ParamRequest],
+                                    context: Optional[CallContext]) -> BinaryResponse:
+        """
+        Corresponds to the HTTP DELETE method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def post_with_binary_response(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+                                  request_parameters: Optional[ParamRequest], request_body: Any,
+                                  context: Optional[CallContext]) -> BinaryResponse:
+        """
+        Corresponds to the HTTP POST method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param request_body: The optional request body to send.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def post(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+             request_parameters: Optional[ParamRequest], request_body: Any,
+             response_type: Type[T],
+             context: Optional[CallContext]) -> T:
+        """
+        Corresponds to the HTTP POST method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param request_body: The optional request body to send.
+        :param response_type: The type of response to return.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def put_with_binary_response(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+                                 request_parameters: Optional[ParamRequest], request_body: Any,
+                                 context: Optional[CallContext]) -> BinaryResponse:
+        """
+        Corresponds to the HTTP PUT method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param request_body: The optional request body to send.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def put(self, relative_path: str, request_headers: Optional[List[RequestHeader]],
+            request_parameters: Optional[ParamRequest], request_body: Any,
+            response_type: Type[T],
+            context: Optional[CallContext]) -> T:
+        """
+        Corresponds to the HTTP PUT method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param request_body: The optional request body to send.
+        :param response_type: The type of response to return.
+        :param context: The optional call context to use.
+        :raise CommunicationException: when an exception occurred communicating with the Online Payments platform
+        :raise ResponseException: when an error response was received from the Online Payments platform
+        """
+
+    @abstractmethod
+    def close_idle_connections(self, idle_time):
+        """
+        Utility method that delegates the call to this communicator's connection
+        if that's an instance of PooledConnection. If not this method does nothing.
+
+        :param idle_time: a datetime.timedelta object indicating the idle time
+        """
+
+    @abstractmethod
+    def close_expired_connections(self):
+        """
+        Utility method that delegates the call to this communicator's connection
+        if that's an instance of PooledConnection. If not this method does nothing.
+        """
+
+    @property
+    @abstractmethod
+    def marshaller(self) -> Marshaller:
+        """
+        :return: The Marshaller object associated with this communicator. Never None.
+        """

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/idempotence_exception.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .api_exception import ApiException
+
+from onlinepayments.sdk.domain.api_error import APIError
+
+
+class IdempotenceException(ApiException):
+    """
+    Represents an error response from the payment platform when an idempotent request failed because the first request has not finished yet.
+    """
+
+    def __init__(self, idempotence_key: str, idempotence_request_timestamp: int,
+                 status_code: int, response_body: str, error_id: Optional[str], errors: Optional[List[APIError]],
+                 message: str = "the payment platform returned a duplicate request error response"):
+        super(IdempotenceException, self).__init__(status_code, response_body, error_id, errors, message)
+        self.__idempotence_key = idempotence_key
+        self.__idempotence_request_timestamp = idempotence_request_timestamp
+
+    @property
+    def idempotence_key(self) -> str:
+        """
+        :return: The key that was used for the idempotent request.
+        """
+        return self.__idempotence_key
+
+    @property
+    def idempotence_request_timestamp(self) -> int:
+        """
+        :return: The request timestamp of the first idempotent request with the same key.
+        """
+        return self.__idempotence_request_timestamp

{onlinepayments-sdk-python3-4.22.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.22.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.22.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()