168 lines
4.2 KiB
Python
168 lines
4.2 KiB
Python
import json
|
|
import pickle
|
|
import datetime
|
|
import struct
|
|
import io
|
|
|
|
|
|
def json_default_converter(o):
|
|
"""
|
|
Default formatter for json
|
|
It's used when the json serializer does not know
|
|
how to serialise a type
|
|
:param o:
|
|
:return:
|
|
"""
|
|
if isinstance(o, (datetime.date, datetime.datetime)):
|
|
return o.isoformat()
|
|
|
|
|
|
class Serializer:
|
|
HEADER_FORMAT = "cH"
|
|
|
|
def __init__(self):
|
|
self._cache = []
|
|
|
|
# add builtin serializers
|
|
self._cache.append(EventSerializer())
|
|
self._cache.append(PickleSerializer())
|
|
|
|
def register(self, serializer):
|
|
"""
|
|
Register the list of all know serializers
|
|
:param serializer:
|
|
:return:
|
|
"""
|
|
self._cache.append(serializer)
|
|
|
|
def serialize(self, obj):
|
|
"""
|
|
Get the stream representation of an object
|
|
:param obj:
|
|
:return:
|
|
"""
|
|
serializers = [s for s in self._cache if s.match(obj)]
|
|
|
|
if not serializers:
|
|
raise TypeError(f"Don't know how to serialize {type(obj)}")
|
|
|
|
serializer = serializers[0]
|
|
|
|
stream = io.BytesIO()
|
|
header = struct.pack(Serializer.HEADER_FORMAT, bytes(serializer.name, "utf-8"), serializer.version)
|
|
stream.write(header)
|
|
|
|
return serializer.dump(stream, obj)
|
|
|
|
def deserialize(self, stream):
|
|
"""
|
|
Loads an object from its stream representation
|
|
:param stream:
|
|
:return:
|
|
"""
|
|
header = struct.unpack(Serializer.HEADER_FORMAT, stream.read(4))
|
|
serializers = [s for s in self._cache if s.name == header[0].decode("utf-8") and s.version == header[1]]
|
|
|
|
if not serializers:
|
|
raise TypeError(f"Don't know how serializer name={header[0]}, version={header[1]}")
|
|
|
|
serializer = serializers[0]
|
|
return serializer.load(stream)
|
|
|
|
|
|
class BaseSerializer:
|
|
|
|
def __init__(self, name, version):
|
|
"""
|
|
Create a serializer, given a name and a version
|
|
:param name:
|
|
:param version:
|
|
:return:
|
|
"""
|
|
self.name = name
|
|
self.version = version
|
|
|
|
@staticmethod
|
|
def match(obj):
|
|
"""
|
|
Returns true if self can serialize obj
|
|
:param obj:
|
|
:return:
|
|
"""
|
|
pass
|
|
|
|
def dump(self, stream, obj):
|
|
"""
|
|
Returns the byte representation of how the object should be serialized
|
|
|
|
:param stream: to write to
|
|
:param obj:
|
|
:return: stream of bytes
|
|
"""
|
|
pass
|
|
|
|
def load(self, stream):
|
|
"""
|
|
From a stream of bytes, create the object
|
|
:param stream:
|
|
:return: object
|
|
"""
|
|
pass
|
|
|
|
@staticmethod
|
|
def get_class(kls):
|
|
parts = kls.split('.')
|
|
module = ".".join(parts[:-1])
|
|
m = __import__(module)
|
|
for comp in parts[1:]:
|
|
m = getattr(m, comp)
|
|
return m
|
|
|
|
@staticmethod
|
|
def get_full_qualified_name(obj):
|
|
module = obj.__class__.__module__
|
|
if module is None or module == str.__class__.__module__:
|
|
return obj.__class__.__name__ # Avoid reporting __builtin__
|
|
else:
|
|
return module + '.' + obj.__class__.__name__
|
|
|
|
|
|
class EventSerializer(BaseSerializer):
|
|
@staticmethod
|
|
def match(obj):
|
|
return BaseSerializer.get_full_qualified_name(obj) == "sdp.sheerkaDataProvider.Event"
|
|
|
|
def __init__(self):
|
|
BaseSerializer.__init__(self, "E", 1)
|
|
|
|
def dump(self, stream, obj):
|
|
stream.write(obj.to_json().encode("utf-8"))
|
|
stream.seek(0)
|
|
return stream
|
|
|
|
def load(self, stream):
|
|
json_stream = stream.read().decode("utf-8")
|
|
json_message = json.loads(json_stream)
|
|
event = BaseSerializer.get_class("sdp.sheerkaDataProvider.Event")()
|
|
event.from_json(json_message)
|
|
return event
|
|
|
|
|
|
class PickleSerializer(BaseSerializer):
|
|
@staticmethod
|
|
def match(obj):
|
|
return BaseSerializer.get_full_qualified_name(obj) == "sdp.sheerkaDataProvider.State"
|
|
|
|
def __init__(self):
|
|
BaseSerializer.__init__(self, "P", 1)
|
|
|
|
def dump(self, stream, obj):
|
|
stream.write(pickle.dumps(obj))
|
|
stream.seek(0)
|
|
return stream
|
|
|
|
def load(self, stream):
|
|
return pickle.loads(stream.read())
|
|
|
|
|