diff --git a/hazelcast/serialization/api.py b/hazelcast/serialization/api.py
index 1d3bfead58..6eead8c1db 100644
--- a/hazelcast/serialization/api.py
+++ b/hazelcast/serialization/api.py
@@ -236,7 +236,7 @@ def skip_bytes(self, count):
 
     def read_boolean(self):
         """Reads 1 byte from input stream and convert it to a bool value.
-        
+
         Returns:
             bool: The bool value read.
         """
@@ -252,7 +252,7 @@ def read_byte(self):
 
     def read_unsigned_byte(self):
         """Reads 1 byte from input stream, zero-extends it and returns.
-        
+
         Returns:
             int: The unsigned byte value read.
         """
@@ -260,7 +260,7 @@ def read_unsigned_byte(self):
 
     def read_short(self):
         """Reads 2 bytes from input stream and returns a short value.
-        
+
         Returns:
             int: The short value read.
         """
@@ -268,7 +268,7 @@ def read_short(self):
 
     def read_unsigned_short(self):
         """Reads 2 bytes from input stream and returns an int value.
-        
+
         Returns:
             int: The unsigned short value read.
         """
@@ -284,7 +284,7 @@ def read_char(self):
 
     def read_int(self):
         """Reads 4 bytes from input stream and returns an int value.
-        
+
         Returns:
             int: The int value read.
         """
@@ -292,7 +292,7 @@ def read_int(self):
 
     def read_long(self):
         """Reads 8 bytes from input stream and returns a long value.
-        
+
         Returns:
             int: The int value read.
         """
@@ -300,7 +300,7 @@ def read_long(self):
 
     def read_float(self):
         """Reads 4 bytes from input stream and returns a float value.
-        
+
         Returns:
             float: The float value read.
         """
@@ -308,7 +308,7 @@ def read_float(self):
 
     def read_double(self):
         """Reads 8 bytes from input stream and returns a double value.
-        
+
         Returns:
             float: The double value read.
         """
@@ -316,7 +316,7 @@ def read_double(self):
 
     def read_utf(self):
         """Reads a UTF-8 string from input stream and returns it.
-        
+
         Returns:
             str: The UTF-8 string read.
         """
@@ -324,7 +324,7 @@ def read_utf(self):
 
     def read_byte_array(self):
         """Reads a byte array from input stream and returns it.
-        
+
         Returns:
             bytearray: The byte array read.
         """
@@ -332,7 +332,7 @@ def read_byte_array(self):
 
     def read_boolean_array(self):
         """Reads a bool array from input stream and returns it.
-        
+
         Returns:
             list[bool]: The bool array read.
         """
@@ -340,7 +340,7 @@ def read_boolean_array(self):
 
     def read_char_array(self):
         """Reads a char array from input stream and returns it.
-        
+
         Returns:
             list[str]: The char array read.
         """
@@ -348,7 +348,7 @@ def read_char_array(self):
 
     def read_int_array(self):
         """Reads a int array from input stream and returns it.
-        
+
         Returns:
             list[int]: The int array read.
         """
@@ -356,7 +356,7 @@ def read_int_array(self):
 
     def read_long_array(self):
         """Reads a long array from input stream and returns it.
-        
+
         Returns:
             list[int]: The long array read.
         """
@@ -364,7 +364,7 @@ def read_long_array(self):
 
     def read_double_array(self):
         """Reads a double array from input stream and returns it.
-        
+
         Returns:
             list[float]: The double array read.
         """
@@ -372,7 +372,7 @@ def read_double_array(self):
 
     def read_float_array(self):
         """Reads a float array from input stream and returns it.
-        
+
         Returns:
             list[float]: The float array read.
         """
@@ -380,7 +380,7 @@ def read_float_array(self):
 
     def read_short_array(self):
         """Reads a short array from input stream and returns it.
-        
+
         Returns:
             list[int]: The short array read.
         """
@@ -388,7 +388,7 @@ def read_short_array(self):
 
     def read_utf_array(self):
         """Reads a UTF-8 string array from input stream and returns it.
-        
+
         Returns:
             list[str]: The UTF-8 string array read.
         """
@@ -396,7 +396,7 @@ def read_utf_array(self):
 
     def read_object(self):
         """Reads a object from input stream and returns it.
-        
+
         Returns:
             The object read.
         """
@@ -412,7 +412,7 @@ def get_byte_order(self):
 
     def position(self):
         """Returns current position in buffer.
-        
+
         Returns:
             int: Current position in buffer.
         """
@@ -420,7 +420,7 @@ def position(self):
 
     def size(self):
         """Returns size of buffer.
-        
+
         Returns:
             int: size of buffer.
         """
@@ -440,7 +440,9 @@ def write_data(self, object_data_output):
         Args:
             object_data_output (hazelcast.serialization.api.ObjectDataOutput): The output.
         """
-        raise NotImplementedError("read_data must be implemented to serialize this IdentifiedDataSerializable")
+        raise NotImplementedError(
+            "read_data must be implemented to serialize this IdentifiedDataSerializable"
+        )
 
     def read_data(self, object_data_input):
         """Reads fields from the input stream.
@@ -448,23 +450,29 @@ def read_data(self, object_data_input):
         Args:
             object_data_input (hazelcast.serialization.api.ObjectDataInput): The input.
         """
-        raise NotImplementedError("read_data must be implemented to deserialize this IdentifiedDataSerializable")
+        raise NotImplementedError(
+            "read_data must be implemented to deserialize this IdentifiedDataSerializable"
+        )
 
     def get_factory_id(self):
         """Returns DataSerializableFactory factory id for this class.
-        
+
         Returns:
             int: The factory id.
         """
-        raise NotImplementedError("This method must return the factory ID for this IdentifiedDataSerializable")
+        raise NotImplementedError(
+            "This method must return the factory ID for this IdentifiedDataSerializable"
+        )
 
     def get_class_id(self):
         """Returns type identifier for this class. Id should be unique per DataSerializableFactory.
-        
+
         Returns:
             int: The type id.
         """
-        raise NotImplementedError("This method must return the class ID for this IdentifiedDataSerializable")
+        raise NotImplementedError(
+            "This method must return the class ID for this IdentifiedDataSerializable"
+        )
 
 
 class Portable(object):
@@ -496,7 +504,7 @@ def read_portable(self, reader):
 
     def get_factory_id(self):
         """Returns PortableFactory id for this portable class
-        
+
         Returns:
             int: The factory id.
         """
@@ -504,7 +512,7 @@ def get_factory_id(self):
 
     def get_class_id(self):
         """Returns class identifier for this portable class. Class id should be unique per PortableFactory.
-        
+
         Returns:
             int: The class id.
         """
@@ -557,7 +565,7 @@ class PortableReader(object):
 
     def get_version(self):
         """Returns the global version of portable classes.
-        
+
         Returns:
             int: Global version of portable classes.
         """
@@ -576,7 +584,7 @@ def has_field(self, field_name):
 
     def get_field_names(self):
         """Returns the set of field names on this portable class.
-        
+
         Returns:
             set: Set of field names on this portable class.
         """
@@ -827,7 +835,7 @@ def read_portable_array(self, field_name):
     def get_raw_data_input(self):
         """After reading portable fields, one can read remaining fields in old fashioned way
         consecutively from the end of stream. After get_raw_data_input() called, no data can be read.
-        
+
         Returns:
             hazelcast.serialization.api.ObjectDataInput: The input.
         """
@@ -1032,9 +1040,8 @@ def write_portable_array(self, field_name, values):
     def get_raw_data_output(self):
         """After writing portable fields, one can write remaining fields in old fashioned way
         consecutively at the end of stream. After get_raw_data_output() called, no data can be written.
-        
+
         Returns:
             hazelcast.serialization.api.ObjectDataOutput: The output.
         """
         raise NotImplementedError()
-
diff --git a/hazelcast/serialization/base.py b/hazelcast/serialization/base.py
index c70edeb1fe..de2634c42a 100644
--- a/hazelcast/serialization/base.py
+++ b/hazelcast/serialization/base.py
@@ -44,7 +44,9 @@ def index_for_default_type(type_id):
 
 
 class BaseSerializationService(object):
-    def __init__(self, version, global_partition_strategy, output_buffer_size, is_big_endian, int_type):
+    def __init__(
+        self, version, global_partition_strategy, output_buffer_size, is_big_endian, int_type
+    ):
         self._registry = SerializerRegistry(int_type)
         self._version = version
         self._global_partition_strategy = global_partition_strategy
@@ -116,7 +118,9 @@ def to_object(self, data):
 
     def write_object(self, out, obj):
         if isinstance(obj, Data):
-            raise HazelcastSerializationError("Cannot write a Data instance! Use write_data(out, data) instead.")
+            raise HazelcastSerializationError(
+                "Cannot write a Data instance! Use write_data(out, data) instead."
+            )
         try:
             serializer = self._registry.serializer_for(obj)
             out.write_int(serializer.get_type_id())
@@ -130,7 +134,9 @@ def read_object(self, inp):
             serializer = self._registry.serializer_by_type_id(type_id)
             if serializer is None:
                 if self._active:
-                    raise HazelcastSerializationError("Missing Serializer for type-id: %s" % type_id)
+                    raise HazelcastSerializationError(
+                        "Missing Serializer for type-id: %s" % type_id
+                    )
                 else:
                     raise HazelcastInstanceNotActiveError()
             return serializer.read(inp)
@@ -139,11 +145,17 @@ def read_object(self, inp):
 
     def _calculate_partitioning_hash(self, obj, partitioning_strategy):
         partitioning_hash = 0
-        _ps = partitioning_strategy if partitioning_strategy is not None else self._global_partition_strategy
+        _ps = (
+            partitioning_strategy
+            if partitioning_strategy is not None
+            else self._global_partition_strategy
+        )
         pk = _ps(obj)
         if pk is not None and pk is not obj:
             partitioning_key = self.to_data(pk, empty_partitioning_strategy)
-            partitioning_hash = 0 if partitioning_key is None else partitioning_key.get_partition_hash()
+            partitioning_hash = (
+                0 if partitioning_key is None else partitioning_key.get_partition_hash()
+            )
         return partitioning_hash
 
     def _create_data_output(self):
@@ -231,7 +243,9 @@ def serializer_for(self, obj):
             serializer = self.lookup_python_serializer(obj_type)
 
         if serializer is None:
-            raise HazelcastSerializationError("There is no suitable serializer for:" + str(obj_type))
+            raise HazelcastSerializationError(
+                "There is no suitable serializer for:" + str(obj_type)
+            )
         return serializer
 
     def lookup_default_serializer(self, obj_type, obj):
@@ -286,7 +300,9 @@ def lookup_global_serializer(self, obj_type):
 
     def register_constant_serializer(self, serializer, object_type=None):
         stream_serializer = serializer
-        self._constant_type_ids[index_for_default_type(stream_serializer.get_type_id())] = stream_serializer
+        self._constant_type_ids[
+            index_for_default_type(stream_serializer.get_type_id())
+        ] = stream_serializer
         if object_type is not None:
             self._constant_type_dict[object_type] = stream_serializer
 
@@ -297,15 +313,19 @@ def safe_register_serializer(self, stream_serializer, obj_type=None):
                     raise ValueError("[%s] serializer cannot be overridden!" % obj_type)
                 current = self._type_dict.get(obj_type, None)
                 if current is not None and current.__class__ != stream_serializer.__class__:
-                    raise ValueError("Serializer[%s] has been already registered for type: %s"
-                                     % (current.__class__, obj_type))
+                    raise ValueError(
+                        "Serializer[%s] has been already registered for type: %s"
+                        % (current.__class__, obj_type)
+                    )
                 else:
                     self._type_dict[obj_type] = stream_serializer
             serializer_type_id = stream_serializer.get_type_id()
             current = self._id_dic.get(serializer_type_id, None)
             if current is not None and current.__class__ != stream_serializer.__class__:
-                raise ValueError("Serializer[%s] has been already registered for type-id: %s"
-                                 % (current.__class__, serializer_type_id))
+                raise ValueError(
+                    "Serializer[%s] has been already registered for type-id: %s"
+                    % (current.__class__, serializer_type_id)
+                )
             else:
                 self._id_dic[serializer_type_id] = stream_serializer
             return current is None
diff --git a/hazelcast/serialization/bits.py b/hazelcast/serialization/bits.py
index a6cf574598..34e0ebfbee 100644
--- a/hazelcast/serialization/bits.py
+++ b/hazelcast/serialization/bits.py
@@ -40,16 +40,16 @@
 
 # LIMITS
 MAX_BYTE = 2 ** 7 - 1
-MIN_BYTE = -2 ** 7
+MIN_BYTE = -(2 ** 7)
 
 MAX_SHORT = 2 ** 15 - 1
-MIN_SHORT = -2 ** 15
+MIN_SHORT = -(2 ** 15)
 
 MAX_INT = 2 ** 31 - 1
-MIN_INT = -2 ** 31
+MIN_INT = -(2 ** 31)
 
 MAX_LONG = 2 ** 63 - 1
-MIN_LONG = -2 ** 63
+MIN_LONG = -(2 ** 63)
 
 UUID_MSB_SHIFT = 64
 UUID_MSB_MASK = 0xFFFFFFFFFFFFFFFF << UUID_MSB_SHIFT
diff --git a/hazelcast/serialization/data.py b/hazelcast/serialization/data.py
index a8eca2f268..8574b2fc21 100644
--- a/hazelcast/serialization/data.py
+++ b/hazelcast/serialization/data.py
@@ -21,7 +21,7 @@ def __init__(self, buf):
 
     def to_bytes(self):
         """Returns byte array representation of internal binary format.
-        
+
         Returns:
             bytearray: The byte array representation of internal binary format.
         """
@@ -29,7 +29,7 @@ def to_bytes(self):
 
     def get_type(self):
         """Returns serialization type of binary form.
-        
+
         Returns:
             int: Serialization type of binary form.
         """
@@ -39,7 +39,7 @@ def get_type(self):
 
     def total_size(self):
         """Returns the total size of Data in bytes.
-        
+
         Returns:
             int: Total size of Data in bytes.
         """
@@ -47,7 +47,7 @@ def total_size(self):
 
     def data_size(self):
         """Returns size of internal binary data in bytes.
-        
+
         Returns:
             int: Size of internal binary data in bytes.
         """
@@ -60,7 +60,7 @@ def get_partition_hash(self):
 
         - PartitioningStrategy during serialization.
         - If partition hash is not set then hash_code() is used.
-        
+
         Returns:
             int: Partition hash.
         """
@@ -71,7 +71,7 @@ def get_partition_hash(self):
 
     def is_portable(self):
         """Determines whether this Data is created from a ``Portable`` object or not.
-        
+
         Returns:
             bool: ``True`` if source object is Portable, ``False`` otherwise.
         """
@@ -79,7 +79,7 @@ def is_portable(self):
 
     def hash_code(self):
         """Returns the murmur hash of the internal data.
-        
+
         Returns:
             int: The murmur hash of the internal data.
         """
@@ -98,8 +98,11 @@ def __hash__(self):
         return murmur_hash3_x86_32(bytearray(self._buffer))
 
     def __eq__(self, other):
-        return isinstance(other, Data) and self.total_size() == other.total_size() \
-               and self._buffer == other.to_bytes()
+        return (
+            isinstance(other, Data)
+            and self.total_size() == other.total_size()
+            and self._buffer == other.to_bytes()
+        )
 
     def __len__(self):
         return self.total_size()
diff --git a/hazelcast/serialization/input.py b/hazelcast/serialization/input.py
index 7a801acd42..a06d1424d2 100644
--- a/hazelcast/serialization/input.py
+++ b/hazelcast/serialization/input.py
@@ -32,7 +32,7 @@ def read_into(self, buff, offset=None, length=None):
             raise IndexError()
         if self._pos + _len > self._size:
             _len = self._size - self._pos
-        buff[_off: _off + _len] = self._buffer[self._pos:self._pos + _len]
+        buff[_off : _off + _len] = self._buffer[self._pos : self._pos + _len]
         self._pos += _len
 
     def skip_bytes(self, count):
@@ -173,6 +173,7 @@ def _read_array_fnc(self, read_item_fnc):
 
     def __repr__(self):
         from binascii import hexlify
+
         buf = hexlify(self._buffer)
         pos_ = self._pos * 2
-        return buf[:pos_] + "[" + buf[pos_] + "]" + buf[pos_ + 1:]
+        return buf[:pos_] + "[" + buf[pos_] + "]" + buf[pos_ + 1 :]
diff --git a/hazelcast/serialization/output.py b/hazelcast/serialization/output.py
index f8b6ca5261..391e5eb362 100644
--- a/hazelcast/serialization/output.py
+++ b/hazelcast/serialization/output.py
@@ -31,7 +31,7 @@ def write_from(self, buff, offset=None, length=None):
         elif length == 0:
             return
         self._ensure_available(_len)
-        self._buffer[self._pos: self._pos + _len] = buff
+        self._buffer[self._pos : self._pos + _len] = buff
         self._pos += _len
 
     def write_boolean(self, boolean):
@@ -131,7 +131,7 @@ def write_object(self, val):
         self._service.write_object(self, val)
 
     def to_byte_array(self):
-        return self._buffer[:self._pos]
+        return self._buffer[: self._pos]
 
     def get_byte_order(self):
         if self._is_big_endian:
@@ -164,7 +164,7 @@ def _ensure_available(self, length):
             buffer_length = len(self._buffer)
             new_length = max(buffer_length << 1, buffer_length + length)
             new_buffer = bytearray(new_length)
-            new_buffer[:self._pos] = self._buffer[:self._pos]
+            new_buffer[: self._pos] = self._buffer[: self._pos]
             self._buffer = new_buffer
 
     def _available(self):
@@ -172,9 +172,10 @@ def _available(self):
 
     def __repr__(self):
         from binascii import hexlify
+
         buf = hexlify(self._buffer)
         pos_ = self._pos * 2
-        return buf[:pos_] + "[" + buf[pos_] + "]" + buf[pos_ + 1:]
+        return buf[:pos_] + "[" + buf[pos_] + "]" + buf[pos_ + 1 :]
 
 
 class EmptyObjectDataOutput(ObjectDataOutput):
diff --git a/hazelcast/serialization/portable/__init__.py b/hazelcast/serialization/portable/__init__.py
index d506117dc6..5b90017ba1 100644
--- a/hazelcast/serialization/portable/__init__.py
+++ b/hazelcast/serialization/portable/__init__.py
@@ -1,3 +1,3 @@
 """
 Hazelcast Portable Serialization Module
-"""
\ No newline at end of file
+"""
diff --git a/hazelcast/serialization/portable/classdef.py b/hazelcast/serialization/portable/classdef.py
index 4b5446f18c..e532e8555a 100644
--- a/hazelcast/serialization/portable/classdef.py
+++ b/hazelcast/serialization/portable/classdef.py
@@ -35,20 +35,27 @@ def __init__(self, index, field_name, field_type, version, factory_id=0, class_i
         self.class_id = class_id
 
     def __eq__(self, other):
-        return isinstance(other, self.__class__) \
-               and (self.index, self.field_name, self.field_type, self.version, self.factory_id, self.class_id) == \
-               (other.index, other.field_name, other.field_type, other.version, other.factory_id, other.class_id)
+        return (
+            isinstance(other, FieldDefinition)
+            and self.index == other.index
+            and self.field_name == other.field_name
+            and self.version == other.version
+            and self.factory_id == other.factory_id
+            and self.class_id == other.class_id
+        )
 
     def __ne__(self, other):
         return not self.__eq__(other)
 
     def __repr__(self):
-        return "FieldDefinition(ix=%s, name=%s, type=%s, version=%s, fid=%s, cid=%s)" % (self.index,
-                                                                                         self.field_name,
-                                                                                         self.field_type,
-                                                                                         self.version,
-                                                                                         self.factory_id,
-                                                                                         self.class_id)
+        return "FieldDefinition(ix=%s, name=%s, type=%s, version=%s, fid=%s, cid=%s)" % (
+            self.index,
+            self.field_name,
+            self.field_type,
+            self.version,
+            self.factory_id,
+            self.class_id,
+        )
 
 
 class ClassDefinition(object):
@@ -99,14 +106,24 @@ def set_version_if_not_set(self, version):
             self.version = version
 
     def __eq__(self, other):
-        return isinstance(other, self.__class__) and (self.factory_id, self.class_id, self.version, self.field_defs) == \
-               (other.factory_id, other.class_id, other.version, other.field_defs)
+        return (
+            isinstance(other, ClassDefinition)
+            and self.factory_id == other.factory_id
+            and self.class_id == other.class_id
+            and self.version == other.version
+            and self.field_defs == other.field_defs
+        )
 
     def __ne__(self, other):
         return not self.__eq__(other)
 
     def __repr__(self):
-        return "fid:%s, cid:%s, v:%s, fields:%s" % (self.factory_id, self.class_id, self.version, self.field_defs)
+        return "fid:%s, cid:%s, v:%s, fields:%s" % (
+            self.factory_id,
+            self.class_id,
+            self.version,
+            self.field_defs,
+        )
 
     def __hash__(self):
         return hash((self.factory_id, self.class_id, self.version))
@@ -125,8 +142,13 @@ def __init__(self, factory_id, class_id, version=0):
     def add_portable_field(self, field_name, class_def):
         if class_def.class_id is None or class_def.class_id == 0:
             raise ValueError("Portable class id cannot be zero!")
-        self._add_field_by_type(field_name, FieldType.PORTABLE, class_def.version,
-                                class_def.factory_id, class_def.class_id)
+        self._add_field_by_type(
+            field_name,
+            FieldType.PORTABLE,
+            class_def.version,
+            class_def.factory_id,
+            class_def.class_id,
+        )
         return self
 
     def add_byte_field(self, field_name):
@@ -168,8 +190,13 @@ def add_utf_field(self, field_name):
     def add_portable_array_field(self, field_name, class_def):
         if class_def.class_id is None or class_def.class_id == 0:
             raise ValueError("Portable class id cannot be zero!")
-        self._add_field_by_type(field_name, FieldType.PORTABLE_ARRAY, class_def.version,
-                                class_def.factory_id, class_def.class_id)
+        self._add_field_by_type(
+            field_name,
+            FieldType.PORTABLE_ARRAY,
+            class_def.version,
+            class_def.factory_id,
+            class_def.class_id,
+        )
         return self
 
     def add_byte_array_field(self, field_name):
@@ -231,4 +258,6 @@ def _add_field_by_type(self, field_name, field_type, version, factory_id=0, clas
 
     def _check(self):
         if self._done:
-            raise HazelcastSerializationError("ClassDefinition is already built for %s" % self.class_id)
+            raise HazelcastSerializationError(
+                "ClassDefinition is already built for %s" % self.class_id
+            )
diff --git a/hazelcast/serialization/portable/context.py b/hazelcast/serialization/portable/context.py
index 3213b6e8be..26ab465aca 100644
--- a/hazelcast/serialization/portable/context.py
+++ b/hazelcast/serialization/portable/context.py
@@ -3,7 +3,12 @@
 from hazelcast import util
 from hazelcast.errors import HazelcastSerializationError
 from hazelcast.serialization import bits
-from hazelcast.serialization.portable.classdef import ClassDefinition, ClassDefinitionBuilder, FieldType, FieldDefinition
+from hazelcast.serialization.portable.classdef import (
+    ClassDefinition,
+    ClassDefinitionBuilder,
+    FieldType,
+    FieldDefinition,
+)
 from hazelcast.serialization.portable.writer import ClassDefinitionWriter
 from hazelcast.six.moves import range
 
@@ -56,7 +61,9 @@ def read_class_definition(self, data_in, factory_id, class_id, version):
                 # TODO: what there's a null inner Portable field
                 if register:
                     field_version = data_in.read_int()
-                    self.read_class_definition(data_in, field_factory_id, field_class_id, field_version)
+                    self.read_class_definition(
+                        data_in, field_factory_id, field_class_id, field_version
+                    )
             elif field_type == FieldType.PORTABLE_ARRAY:
                 k = data_in.read_int()
                 field_factory_id = data_in.read_int()
@@ -67,11 +74,21 @@ def read_class_definition(self, data_in, factory_id, class_id, version):
                     p = data_in.read_int()
                     data_in.set_position(p)
                     field_version = data_in.read_int()
-                    self.read_class_definition(data_in, field_factory_id, field_class_id, field_version)
+                    self.read_class_definition(
+                        data_in, field_factory_id, field_class_id, field_version
+                    )
                 else:
                     register = False
-            builder.add_field_def(FieldDefinition(i, field_name.decode('ascii'), field_type, field_version,
-                                                  field_factory_id, field_class_id))
+            builder.add_field_def(
+                FieldDefinition(
+                    i,
+                    field_name.decode("ascii"),
+                    field_type,
+                    field_version,
+                    field_factory_id,
+                    field_class_id,
+                )
+            )
         class_def = builder.build()
         if register:
             class_def = self.register_class_definition(class_def)
@@ -126,7 +143,9 @@ def register(self, class_def):
             if class_def is None:
                 return None
             if class_def.factory_id != self._factory_id:
-                raise HazelcastSerializationError("Invalid factory-id! %s -> %s" % (self._factory_id, class_def))
+                raise HazelcastSerializationError(
+                    "Invalid factory-id! %s -> %s" % (self._factory_id, class_def)
+                )
             if isinstance(class_def, ClassDefinition):
                 class_def.set_version_if_not_set(self._portable_version)
             combined_key = (class_def.class_id, class_def.version)
@@ -136,8 +155,10 @@ def register(self, class_def):
             current_class_def = self._versioned_definitions[combined_key]
             if isinstance(current_class_def, ClassDefinition):
                 if current_class_def != class_def:
-                    raise HazelcastSerializationError("Incompatible class-definitions with same class-id: %s vs %s"
-                                                      % (class_def, current_class_def))
+                    raise HazelcastSerializationError(
+                        "Incompatible class-definitions with same class-id: %s vs %s"
+                        % (class_def, current_class_def)
+                    )
                 return current_class_def
             self._versioned_definitions[combined_key] = class_def
             return class_def
diff --git a/hazelcast/serialization/portable/reader.py b/hazelcast/serialization/portable/reader.py
index 5c600ae00b..79e34c6489 100644
--- a/hazelcast/serialization/portable/reader.py
+++ b/hazelcast/serialization/portable/reader.py
@@ -18,7 +18,9 @@ def __init__(self, portable_serializer, data_input, class_def):
         except Exception:
             raise HazelcastSerializationError()
         if field_count != class_def.get_field_count():
-            raise ValueError("Field count(%s) in stream does not match! %s" % (field_count, class_def))
+            raise ValueError(
+                "Field count(%s) in stream does not match! %s" % (field_count, class_def)
+            )
         self._offset = data_input.position()
         self._raw = False
 
@@ -210,14 +212,18 @@ def read_portable_array(self, field_name):
                 for i in range(0, length):
                     start = self._in.read_int(offset + i * bits.INT_SIZE_IN_BYTES)
                     self._in.set_position(start)
-                    portables[i] = self._portable_serializer.read_internal(self._in, factory_id, class_id)
+                    portables[i] = self._portable_serializer.read_internal(
+                        self._in, factory_id, class_id
+                    )
             return portables
         finally:
             self._in.set_position(current_pos)
 
     def get_raw_data_input(self):
         if not self._raw:
-            pos = self._in.read_int(self._offset + self._class_def.get_field_count() * bits.INT_SIZE_IN_BYTES)
+            pos = self._in.read_int(
+                self._offset + self._class_def.get_field_count() * bits.INT_SIZE_IN_BYTES
+            )
             self._in.set_position(pos)
         self._raw = True
         return self._in
@@ -227,7 +233,9 @@ def end(self):
 
     def _read_position(self, field_name, field_type):
         if self._raw:
-            raise HazelcastSerializationError("Cannot read Portable fields after get_raw_data_input() is called!")
+            raise HazelcastSerializationError(
+                "Cannot read Portable fields after get_raw_data_input() is called!"
+            )
         fd = self._class_def.get_field(field_name)
         if fd is None:
             return self._read_nested_position(field_name, field_type)
@@ -260,8 +268,10 @@ def _read_nested_position(self, field_name, field_type):
         raise self._create_unknown_field_exception(field_name)
 
     def _create_unknown_field_exception(self, field_name):
-        return HazelcastSerializationError("Unknown field name: '%s' for ClassDefinition(id=%s, version=%s)"
-                                           % (field_name, self._class_def.class_id, self._class_def.version))
+        return HazelcastSerializationError(
+            "Unknown field name: '%s' for ClassDefinition(id=%s, version=%s)"
+            % (field_name, self._class_def.class_id, self._class_def.version)
+        )
 
     def _read_position_by_field_def(self, fd):
         pos = self._in.read_int(self._offset + fd.index * bits.INT_SIZE_IN_BYTES)
@@ -272,13 +282,16 @@ def _read_position_by_field_def(self, fd):
 
 def _check_factory_and_class(field_def, factory_id, class_id):
     if factory_id != field_def.factory_id:
-        raise ValueError("Invalid factoryId! Expected: %s, Current: %s" % (factory_id, field_def.factory_id))
+        raise ValueError(
+            "Invalid factoryId! Expected: %s, Current: %s" % (factory_id, field_def.factory_id)
+        )
     if class_id != field_def.class_id:
-        raise ValueError("Invalid classId! Expected: %s, Current: %s" % (class_id, field_def.class_id))
+        raise ValueError(
+            "Invalid classId! Expected: %s, Current: %s" % (class_id, field_def.class_id)
+        )
 
 
 class MorphingPortableReader(DefaultPortableReader):
-
     def read_short(self, field_name):
         fd = self._class_def.get_field(field_name)
         if fd is None:
@@ -470,5 +483,7 @@ def validate_type_compatibility(self, field_def, expected_type):
             raise self.create_incompatible_class_change_error(field_def, expected_type)
 
     def create_incompatible_class_change_error(self, field_def, expected_type):
-        return TypeError("Incompatible to read %s from %s while reading field: %s on %s"
-                         % (expected_type, field_def.field_type, field_def.field_name, self._class_def))
+        return TypeError(
+            "Incompatible to read %s from %s while reading field: %s on %s"
+            % (expected_type, field_def.field_type, field_def.field_name, self._class_def)
+        )
diff --git a/hazelcast/serialization/portable/serializer.py b/hazelcast/serialization/portable/serializer.py
index 70775c787b..7d7ba48916 100644
--- a/hazelcast/serialization/portable/serializer.py
+++ b/hazelcast/serialization/portable/serializer.py
@@ -45,7 +45,9 @@ def read_internal(self, inp, factory_id, class_id):
     def find_portable_version(self, factory_id, class_id, portable):
         current_version = self._portable_context.get_class_version(factory_id, class_id)
         if current_version < 0:
-            current_version = util.get_portable_version(portable, self._portable_context.portable_version)
+            current_version = util.get_portable_version(
+                portable, self._portable_context.portable_version
+            )
         if current_version > 0:
             self._portable_context.set_class_version(factory_id, class_id, current_version)
         return current_version
@@ -54,11 +56,15 @@ def create_new_portable_instance(self, factory_id, class_id):
         try:
             portable_factory = self._portable_factories[factory_id]
         except KeyError:
-            raise HazelcastSerializationError("Could not find portable_factory for factory-id: %s" % factory_id)
+            raise HazelcastSerializationError(
+                "Could not find portable_factory for factory-id: %s" % factory_id
+            )
 
         portable = portable_factory[class_id]
         if portable is None:
-            raise HazelcastSerializationError("Could not create Portable for class-id: %s" % class_id)
+            raise HazelcastSerializationError(
+                "Could not create Portable for class-id: %s" % class_id
+            )
         return portable()
 
     def create_reader(self, inp, factory_id, class_id, version, portable_version):
@@ -69,7 +75,9 @@ def create_reader(self, inp, factory_id, class_id, version, portable_version):
         cd = self._portable_context.lookup_class_definition(factory_id, class_id, effective_version)
         if cd is None:
             begin = inp.position()
-            cd = self._portable_context.read_class_definition(inp, factory_id, class_id, effective_version)
+            cd = self._portable_context.read_class_definition(
+                inp, factory_id, class_id, effective_version
+            )
             inp.set_position(begin)
 
         if portable_version == effective_version:
diff --git a/hazelcast/serialization/portable/writer.py b/hazelcast/serialization/portable/writer.py
index cdcb80d5ec..94429a9ca6 100644
--- a/hazelcast/serialization/portable/writer.py
+++ b/hazelcast/serialization/portable/writer.py
@@ -143,11 +143,15 @@ def get_raw_data_output(self):
     # internal
     def _set_position(self, field_name, field_type):
         if self._raw:
-            raise HazelcastSerializationError("Cannot write Portable fields after get_raw_data_output() is called!")
+            raise HazelcastSerializationError(
+                "Cannot write Portable fields after get_raw_data_output() is called!"
+            )
         fd = self._class_def.get_field(field_name)
         if fd is None:
-            raise HazelcastSerializationError("Invalid field name:'%s' for ClassDefinition(id:%s , version:%s )"
-                                              % (field_name, self._class_def.class_id, self._class_def.version))
+            raise HazelcastSerializationError(
+                "Invalid field name:'%s' for ClassDefinition(id:%s , version:%s )"
+                % (field_name, self._class_def.class_id, self._class_def.version)
+            )
         if field_name not in self._writen_fields:
             self._write_field_def(fd.index, field_name, field_type)
             self._writen_fields.add(field_name)
@@ -171,17 +175,23 @@ def end(self):
 
 def _check_portable_attributes(field_def, portable):
     if field_def.factory_id != portable.get_factory_id():
-        raise HazelcastSerializationError("Wrong Portable type! Generic portable types are not supported! "
-                                          "Expected factory-id: %s, Actual factory-id: %s"
-                                          % (field_def.factory_id, portable.get_factory_id()))
+        raise HazelcastSerializationError(
+            "Wrong Portable type! Generic portable types are not supported! "
+            "Expected factory-id: %s, Actual factory-id: %s"
+            % (field_def.factory_id, portable.get_factory_id())
+        )
     if field_def.class_id != portable.get_class_id():
-        raise HazelcastSerializationError("Wrong Portable type! Generic portable types are not supported! "
-                                          "Expected class-id: %s, Actual class-id: %s"
-                                          % (field_def.class_id, portable.get_class_id()))
+        raise HazelcastSerializationError(
+            "Wrong Portable type! Generic portable types are not supported! "
+            "Expected class-id: %s, Actual class-id: %s"
+            % (field_def.class_id, portable.get_class_id())
+        )
 
 
 class ClassDefinitionWriter(PortableWriter):
-    def __init__(self, portable_context, factory_id=None, class_id=None, version=None, class_def_builder=None):
+    def __init__(
+        self, portable_context, factory_id=None, class_id=None, version=None, class_def_builder=None
+    ):
         self.portable_context = portable_context
         if class_def_builder is None:
             self._builder = ClassDefinitionBuilder(factory_id, class_id, version)
@@ -244,7 +254,9 @@ def write_utf_array(self, field_name, values):
 
     def write_portable(self, field_name, portable):
         if portable is None:
-            raise HazelcastSerializationError("Cannot write None portable without explicitly registering class definition!")
+            raise HazelcastSerializationError(
+                "Cannot write None portable without explicitly registering class definition!"
+            )
         version = util.get_portable_version(portable, self.portable_context.portable_version)
 
         factory_id = portable.get_factory_id()
@@ -255,22 +267,29 @@ def write_portable(self, field_name, portable):
 
     def write_portable_array(self, field_name, values):
         if values is None or len(values) == 0:
-            raise HazelcastSerializationError("Cannot write None portable without explicitly registering class definition!")
+            raise HazelcastSerializationError(
+                "Cannot write None portable without explicitly registering class definition!"
+            )
         portable = values[0]
         _class_id = portable.get_class_id()
         for i in range(1, len(values)):
             if values[i].get_class_id() != _class_id:
                 raise ValueError("Detected different class-ids in portable array!")
         version = util.get_portable_version(portable, self.portable_context.portable_version)
-        nested_builder = ClassDefinitionBuilder(portable.get_factory_id(), portable.get_class_id(), version)
+        nested_builder = ClassDefinitionBuilder(
+            portable.get_factory_id(), portable.get_class_id(), version
+        )
         nested_class_def = self._create_nested_class_def(portable, nested_builder)
         self._builder.add_portable_array_field(field_name, nested_class_def)
 
     def write_null_portable(self, field_name, factory_id, class_id):
-        nested_class_def = self.portable_context.lookup_class_definition(factory_id, class_id,
-                                                                         self.portable_context.portable_version)
+        nested_class_def = self.portable_context.lookup_class_definition(
+            factory_id, class_id, self.portable_context.portable_version
+        )
         if nested_class_def is None:
-            raise HazelcastSerializationError("Cannot write None portable without explicitly registering class definition!")
+            raise HazelcastSerializationError(
+                "Cannot write None portable without explicitly registering class definition!"
+            )
         self._builder.add_portable_field(field_name, nested_class_def)
 
     def get_raw_data_output(self):
diff --git a/hazelcast/serialization/serializer.py b/hazelcast/serialization/serializer.py
index 77d4af0ad2..30f253c83b 100644
--- a/hazelcast/serialization/serializer.py
+++ b/hazelcast/serialization/serializer.py
@@ -285,7 +285,7 @@ def write(self, out, obj):
         end_index = -1 if (type(obj) == long and six.PY2) else None
         hex_str = hex(the_big_int)[2:end_index]
         if len(hex_str) % 2 == 1:
-            prefix = '0'  # "f" if obj < 0 else "0"
+            prefix = "0"  # "f" if obj < 0 else "0"
             hex_str = prefix + hex_str
         num_array = bytearray(binascii.unhexlify(bytearray(hex_str, encoding="utf-8")))
         if obj < 0:
@@ -364,18 +364,23 @@ def write(self, out, obj):
     def read(self, inp):
         is_identified = inp.read_boolean()
         if not is_identified:
-            raise HazelcastSerializationError("Native clients only support IdentifiedDataSerializable!")
+            raise HazelcastSerializationError(
+                "Native clients only support IdentifiedDataSerializable!"
+            )
         factory_id = inp.read_int()
         class_id = inp.read_int()
 
         factory = self._factories.get(factory_id, None)
         if factory is None:
             raise HazelcastSerializationError(
-                "No DataSerializerFactory registered for namespace: %s" % factory_id)
+                "No DataSerializerFactory registered for namespace: %s" % factory_id
+            )
         identified = factory.get(class_id, None)
         if identified is None:
             raise HazelcastSerializationError(
-                "%s is not be able to create an instance for id: %s on factoryId: %s" % (factory, class_id, factory_id))
+                "%s is not be able to create an instance for id: %s on factoryId: %s"
+                % (factory, class_id, factory_id)
+            )
         instance = identified()
         instance.read_data(inp)
         return instance
diff --git a/hazelcast/serialization/service.py b/hazelcast/serialization/service.py
index ff959967e3..bcfbc3d854 100644
--- a/hazelcast/serialization/service.py
+++ b/hazelcast/serialization/service.py
@@ -17,16 +17,27 @@ def default_partition_strategy(key):
 
 
 class SerializationServiceV1(BaseSerializationService):
-
-    def __init__(self, config, version=1,
-                 global_partition_strategy=default_partition_strategy,
-                 output_buffer_size=DEFAULT_OUT_BUFFER_SIZE):
-        super(SerializationServiceV1, self).__init__(version, global_partition_strategy, output_buffer_size,
-                                                     config.is_big_endian,
-                                                     config.default_int_type)
+    def __init__(
+        self,
+        config,
+        version=1,
+        global_partition_strategy=default_partition_strategy,
+        output_buffer_size=DEFAULT_OUT_BUFFER_SIZE,
+    ):
+        super(SerializationServiceV1, self).__init__(
+            version,
+            global_partition_strategy,
+            output_buffer_size,
+            config.is_big_endian,
+            config.default_int_type,
+        )
         self._portable_context = PortableContext(self, config.portable_version)
-        self.register_class_definitions(config.class_definitions, config.check_class_definition_errors)
-        self._registry._portable_serializer = PortableSerializer(self._portable_context, config.portable_factories)
+        self.register_class_definitions(
+            config.class_definitions, config.check_class_definition_errors
+        )
+        self._registry._portable_serializer = PortableSerializer(
+            self._portable_context, config.portable_factories
+        )
 
         # merge configured factories with built in ones
         factories = {}
@@ -73,7 +84,9 @@ def _register_constant_serializers(self):
         self._registry.register_constant_serializer(JavaClassSerializer())
         self._registry.register_constant_serializer(ArrayListSerializer(), list)
         self._registry.register_constant_serializer(LinkedListSerializer())
-        self._registry.register_constant_serializer(HazelcastJsonValueSerializer(), HazelcastJsonValue)
+        self._registry.register_constant_serializer(
+            HazelcastJsonValueSerializer(), HazelcastJsonValue
+        )
 
         self._registry.safe_register_serializer(self._registry._python_serializer)
 
@@ -88,7 +101,9 @@ def register_class_definitions(self, class_definitions, check_error):
 
             class_id = cd.class_id
             if class_id in class_defs:
-                raise HazelcastSerializationError("Duplicate registration found for class-id: %s" % class_id)
+                raise HazelcastSerializationError(
+                    "Duplicate registration found for class-id: %s" % class_id
+                )
             class_defs[class_id] = cd
 
         for cd in class_definitions:
@@ -112,6 +127,7 @@ def register_class_definition(self, class_definition, factories, check_error):
                 if check_error:
                     raise HazelcastSerializationError(
                         "Could not find registered ClassDefinition for factory-id: %s, class-id: %s"
-                        % (factory_id, class_id))
+                        % (factory_id, class_id)
+                    )
 
         self._portable_context.register_class_definition(class_definition)
diff --git a/pyproject.toml b/pyproject.toml
index aff3d3c4c1..8a368ba5ca 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -16,7 +16,6 @@ exclude = '''
 
       | benchmarks
       | hazelcast/protocol/codec
-      | hazelcast/serialization
       | tests
     )/
   | /hazelcast/(?!(__init__))\w+\.py