A python in memory repository implementation

in_memory_repository.py

import pickle

class BaseRepository:

    def put(self, entity):
        raise NotImplementedError

    def find_by_id(self, entity_id):
        raise NotImplementedError

    def find_all(self):
        raise NotImplementedError

    def remove(self, entity):
        raise NotImplementedError

    def remove_by_id(self, entity_id):
        raise NotImplementedError

    def remove_all(self):
        raise NotImplementedError

    def drop(self):
        raise NotImplementedError
        
class InMemoryRepository(BaseRepository):
    KEY_NAME = "id"

    def __init__(self):
        super().__init__()
        self._storage = {}

    def put(self, entity):
        key = self._key(self._get_id(entity))
        self._storage[key] = self._serialize(entity)

    def remove(self, entity):
        key = self._key(self._get_id(entity))
        del self._storage[key]

    def remove_by_id(self, entity_id):
        key = self._key(entity_id)
        self._storage.pop(key, None)

    def remove_all(self):
        self._storage.clear()

    def drop(self):
        self._storage.clear()

    def find_all(self):
        return [self._deserialize(item) for item in self._storage]

    def find_by_id(self, entity_id):
        key = self._key(entity_id)
        entity = self._storage.get(key, None)
        if not entity:
            return self._deserialize(entity)
        return None

    def _serialize(self, data):
        return pickle.dumps(data)

    def _get_id(self, entity):
        return getattr(entity, self.KEY_NAME)

    def _deserialize(self, data):
        return pickle.loads(data)

    def _key(self, entity_id):
        return "{}".format(entity_id)