Added DefaultParser

sdp/sheerkaSerializer.py

@@ -3,6 +3,7 @@ import pickle
 import datetime
 import struct
 import io
+from dataclasses import dataclass
 
 
 def json_default_converter(o):
@@ -17,15 +18,27 @@ def json_default_converter(o):
         return o.isoformat()
 
 
+@dataclass()
+class SerializerContext:
+    user_name: str
+    origin: str
+
+
 class Serializer:
     HEADER_FORMAT = "cH"
+    USERNAME = "user_name"  # key to store user that as committed the snapshot
+    MODIFICATION_DATE = "modification_date"  #
+    PARENTS = "parents"
+    ORIGIN = "origin"
+    HISTORY = "##history##"
 
     def __init__(self):
         self._cache = []
 
         # add builtin serializers
-        self._cache.append(EventSerializer())
-        self._cache.append(PickleSerializer())
+        self.register(EventSerializer())
+        self.register(PickleSerializer())
+        self.register(ConceptSerializer())
 
     def register(self, serializer):
         """
@@ -35,9 +48,10 @@ class Serializer:
         """
         self._cache.append(serializer)
 
-    def serialize(self, obj):
+    def serialize(self, obj, context):
         """
         Get the stream representation of an object
+        :param context:
         :param obj:
         :return:
         """
@@ -52,11 +66,12 @@ class Serializer:
         header = struct.pack(Serializer.HEADER_FORMAT, bytes(serializer.name, "utf-8"), serializer.version)
         stream.write(header)
 
-        return serializer.dump(stream, obj)
+        return serializer.dump(stream, obj, context)
 
-    def deserialize(self, stream):
+    def deserialize(self, stream, context):
         """
         Loads an object from its stream representation
+        :param context:
         :param stream:
         :return:
         """
@@ -67,7 +82,7 @@ class Serializer:
             raise TypeError(f"Don't know how serializer name={header[0]}, version={header[1]}")
 
         serializer = serializers[0]
-        return serializer.load(stream)
+        return serializer.load(stream, context)
 
 
 class BaseSerializer:
@@ -82,8 +97,7 @@ class BaseSerializer:
         self.name = name
         self.version = version
 
-    @staticmethod
-    def match(obj):
+    def match(self, obj):
         """
         Returns true if self can serialize obj
         :param obj:
@@ -91,26 +105,32 @@ class BaseSerializer:
         """
         pass
 
-    def dump(self, stream, obj):
+    def dump(self, stream, obj, context):
         """
         Returns the byte representation of how the object should be serialized
-
         :param stream: to write to
-        :param obj:
+        :param obj: obj to serialize
+        :param context: additional info needed to dump
         :return: stream of bytes
         """
         pass
 
-    def load(self, stream):
+    def load(self, stream, context):
         """
         From a stream of bytes, create the object
         :param stream:
+        :param context: additional info needed to load
         :return: object
         """
         pass
 
     @staticmethod
     def get_class(kls):
+        """
+        Loads a class from its string full qualified name
+        :param kls:
+        :return:
+        """
         parts = kls.split('.')
         module = ".".join(parts[:-1])
         m = __import__(module)
@@ -120,6 +140,11 @@ class BaseSerializer:
 
     @staticmethod
     def get_full_qualified_name(obj):
+        """
+        Returns the full qualified name of a class (including its module name )
+        :param obj:
+        :return:
+        """
         module = obj.__class__.__module__
         if module is None or module == str.__class__.__module__:
             return obj.__class__.__name__  # Avoid reporting __builtin__
@@ -128,40 +153,73 @@ class BaseSerializer:
 
 
 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"))
+    def match(self, obj):
+        return BaseSerializer.get_full_qualified_name(obj) == "sdp.sheerkaDataProvider.Event"
+
+    def dump(self, stream, obj, context):
+        stream.write(json.dumps(obj.to_dict(), default=json_default_converter).encode("utf-8"))
         stream.seek(0)
         return stream
 
-    def load(self, stream):
+    def load(self, stream, context):
         json_stream = stream.read().decode("utf-8")
-        json_message = json.loads(json_stream)
+        as_dict = json.loads(json_stream)
         event = BaseSerializer.get_class("sdp.sheerkaDataProvider.Event")()
-        event.from_json(json_message)
+        event.from_dict(as_dict)
         return event
 
 
+class ObjectSerializer(BaseSerializer):
+
+    def __init__(self, fully_qualified_name, name="O", version=1):
+        BaseSerializer.__init__(self, name, version)
+        self.fully_qualified_name = fully_qualified_name
+
+    def match(self, obj):
+        return BaseSerializer.get_full_qualified_name(obj) == self.fully_qualified_name
+
+    def dump(self, stream, obj, context):
+        as_json = obj.to_dict()
+        as_json.update({
+            Serializer.HISTORY: {
+                Serializer.USERNAME: context.user_name,
+                Serializer.MODIFICATION_DATE: datetime.datetime.now().isoformat(),
+                Serializer.PARENTS: [getattr(obj, Serializer.ORIGIN)] if hasattr(obj, Serializer.ORIGIN) else []
+            }})
+        stream.write(json.dumps(as_json, default=json_default_converter).encode("utf-8"))
+        stream.seek(0)
+        return stream
+
+    def load(self, stream, context):
+        json_stream = stream.read().decode("utf-8")
+        json_message = json.loads(json_stream)
+        obj = BaseSerializer.get_class(self.fully_qualified_name)()
+        obj.from_dict(json_message)
+        setattr(obj, Serializer.HISTORY, json_message[Serializer.HISTORY])
+
+        return obj
+
+
 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):
+    def match(self, obj):
+        return BaseSerializer.get_full_qualified_name(obj) == "sdp.sheerkaDataProvider.State"
+
+    def dump(self, stream, obj, context):
         stream.write(pickle.dumps(obj))
         stream.seek(0)
         return stream
 
-    def load(self, stream):
+    def load(self, stream, context):
         return pickle.loads(stream.read())
 
 
+class ConceptSerializer(ObjectSerializer):
+    def __init__(self):
+        ObjectSerializer.__init__(self, "core.concept.Concept", "C", 1)