def deserialize(binary: bin, worker: AbstractWorker = None, unbufferizes=True) -> object:
""" This method can deserialize any object PySyft needs to send or store.
This is the high level function for deserializing any object or collection
of objects which PySyft has sent over the wire or stored. It includes three
steps, Decompress, Deserialize, and Detail as described inline below.
Args:
binary (bin): the serialized object to be deserialized.
worker (AbstractWorker): the worker which is acquiring the message content,
for example used to specify the owner of a tensor received(not obvious
for virtual workers)
unbufferizes (bool): there are some cases where we need to perform the decompression
and deserialization part, but we don't need to unbufferize all the message.
This is the case for Plan workers for instance
Returns:
object: the deserialized form of the binary input.
"""
if worker is None:
# TODO[jvmancuso]: This might be worth a standalone function.
worker = syft.framework.hook.local_worker
# 1) Decompress the binary if needed
binary = compression._decompress(binary)
# 2) Deserialize
msg_wrapper = SyftMessagePB()
msg_wrapper.ParseFromString(binary)
# 3) Convert back to a Python object
message_type = msg_wrapper.WhichOneof("contents")
python_obj = _unbufferize(worker, getattr(msg_wrapper, message_type))
return python_obj
def serialize(
obj: object,
worker: AbstractWorker = None,
simplified: bool = False,
force_no_compression: bool = False,
force_no_serialization: bool = False,
force_full_simplification: bool = False,
) -> bin:
"""This method can serialize any object PySyft needs to send or store.
This is the high level function for serializing any object or collection
of objects which PySyft needs to send over the wire. It includes three
steps, Simplify, Serialize, and Compress as described inline below.
Args:
obj (object): the object to be serialized
simplified (bool): in some cases we want to pass in data which has
already been simplified - in which case we must skip double
simplification - which would be bad.... so bad... so... so bad
force_no_compression (bool): If true, this will override ANY module
settings and not compress the objects being serialized. The primary
expected use of this functionality is testing and/or experimentation.
force_no_serialization (bool): Primarily a testing tool, this will force
this method to return human-readable Python objects which is very useful
for testing and debugging (forceably overrides module compression,
serialization, and the 'force_no_compression' override)). In other words,
only simplification operations are performed.
force_full_simplification (bool): Some objects are only partially serialized
by default. For objects where this is the case, setting this flag to True
will force the entire object to be serialized. For example, setting this
flag to True will cause a VirtualWorker to be serialized WITH all of its
tensors while by default VirtualWorker objects only serialize a small
amount of metadata.
Returns:
binary: the serialized form of the object.
"""
if worker is None:
# TODO[jvmancuso]: This might be worth a standalone function.
worker = syft.framework.hook.local_worker
if force_no_serialization:
# 0) Simplify
# bufferize difficult-to-serialize objects. See the _bufferize method
# for unbufferizes on how this works. The general purpose is to handle types
# which the fast serializer cannot handle
simple_objects = obj
if not simplified:
if force_full_simplification:
simple_objects = _force_full_bufferize(worker, obj)
else:
simple_objects = _bufferize(worker, obj)
return simple_objects
# 1) Convert to Protobuf objects
msg_wrapper = SyftMessagePB()
protobuf_obj = _bufferize(worker, obj)
obj_type = type(obj)
if isinstance(obj_type, None):
msg_wrapper.contents_empty_msg.CopyFrom(protobuf_obj)
elif obj_type == ObjectMessage:
msg_wrapper.contents_object_msg.CopyFrom(protobuf_obj)
elif obj_type == TensorCommandMessage:
msg_wrapper.contents_action_msg.CopyFrom(protobuf_obj)
# 2) Serialize
# serialize into a binary
binary = msg_wrapper.SerializeToString()
# 3) Compress
# optionally compress the binary and return the result
# prepend a 1-byte header '0' or '1' to the output stream
# to denote whether output stream is compressed or not
# if compressed stream length is greater than input stream
# we output the input stream as it is with header set to '0'
# otherwise we output the compressed stream with header set to '1'
# even if compressed flag is set to false by the caller we
# output the input stream as it is with header set to '0'
if force_no_compression:
return binary
else:
return compression._compress(binary)
