def __init_subclass__(cls):
super().__init_subclass__()
obligatory_fields = [
"_SUPPORTED_CLASS", "SUPPORTED_CLASS_STATIC_TYPE", "_from_json",
"_to_json"
]
validate_obligatory_fields(cls, obligatory_fields)
SerializerManager.register_serializer(cls,
cls.SUPPORTED_CLASS_STATIC_TYPE)
def restore_book(self, book_name):
book_uri = self._get_book_uri(book_name)
book_uri += "//book.json"
with open(book_uri) as book_in:
json_data = json.loads(book_in.read())
return SerializerManager.deserialize(json_data)
def test_serialization(self):
class OtherSerializableClass(Serializable):
_STATIC_TYPE = "OtherSerializableClass"
_PROPERTIES_TO_SERIALIZE = ["a"]
def initialize(self, a):
self.a = a
return self
def __eq__(self, other):
return self.a == other.a
class MySerializableClass(Serializable):
_STATIC_TYPE = "MySerializableClass"
_PROPERTIES_TO_SERIALIZE = [
"int_val", "int_val_for_composed_class", "float_val", "a_dict",
"a_list", "a_set"
]
def initialize(self, int_val, int_val_for_composed_class,
float_val, a_dict, a_list, a_set):
self.int_val = int_val
self.int_val_for_composed_class = OtherSerializableClass(
).initialize(int_val_for_composed_class)
self.float_val = float_val
self.a_dict = a_dict
self.a_list = a_list
self.a_set = a_set
return self
def __eq__(self, other):
return self.int_val == other.int_val \
and self.int_val_for_composed_class == other.int_val_for_composed_class \
and self.float_val == other.float_val \
and self.a_dict == other.a_dict \
and self.a_list == other.a_list \
and self.a_set == other.a_set
obj = MySerializableClass().initialize(1, 2, 3.5, {
"key1": 1,
"key2": 2
}, [1, 2, 3, 4], {1, 2, 3})
serialized = SerializerManager.serialize(obj)
deserialized = SerializerManager.deserialize(serialized)
self.assertEqual(obj, deserialized)
def from_json(cls, json):
obj = cls()
#TODO jagros - check if all keys from cls._PROPERTIES_TO_SERIALIZE are available in json obj, if not, throw exception
for field_name in cls._PROPERTIES_TO_SERIALIZE:
json_val = json[field_name]
val = SerializerManager.deserialize(json_val)
setattr(obj, field_name, val)
return obj
def to_json(self):
as_dict = {}
for field_name in self._PROPERTIES_TO_SERIALIZE:
val = getattr(self, field_name)
json_val = SerializerManager.serialize(val)
as_dict[field_name] = json_val
return as_dict
def test_class_is_auto_registered_to_serializer_manager_by_inheritance(
self):
static_type = "SerializableClass"
class SerializableClass(Serializable):
_STATIC_TYPE = static_type
_PROPERTIES_TO_SERIALIZE = []
serializableObj = SerializableClass()
SerializerManager.serialize(serializableObj)
class NotSerializableClass:
pass
notSerializableObj = NotSerializableClass()
with self.assertRaises(TypeError) as cm:
SerializerManager.serialize(notSerializableObj)
self.assertEqual(f"Not supported type {type(notSerializableObj)}",
str(cm.exception))
def store_book(self, book):
book_uri = self._get_book_uri(book.name)
save_dir = self._create_subdir_if_not_exists(book_uri)
shutil.copy2(book.path, save_dir)
data = json.dumps(SerializerManager.serialize(book), indent=4, sort_keys=True)
with open(save_dir + "\\book.json", 'w+') as out_file:
print(data, file=out_file)
self._store_unknown_words(save_dir, book.unknown_words)
self._extend_known_words(book.known_words)
self._store_flashcards(save_dir, book.flashcards)
def _from_json(self, json_dict):
return {
key: SerializerManager.deserialize(json_val)
for (key, json_val) in json_dict.items()
}
def _to_json(self, dict_obj):
return {
key: SerializerManager.serialize(obj_val)
for (key, obj_val) in dict_obj.items()
}
def _from_json(self, json_list):
return [SerializerManager.deserialize(elem) for elem in json_list]
def _to_json(self, list_obj):
return [SerializerManager.serialize(elem) for elem in list_obj]
def _from_json(self, json_set):
return set(SerializerManager.deserialize(elem) for elem in json_set)
def _to_json(self, set_obj):
return list(SerializerManager.serialize(elem) for elem in set_obj)