Interactive Very Simple In-Memory Key-Value Store

MemeryStore.py

class Database:
    def __init__(self):
        self.database = {}
        self.msgs = {
            -1: 'INVALID COMMAND',
            0: 'OK',
            1: 'MISSING VALUE',
            2: 'NOT FOUND',
            3: 'TRUE',
            4: 'FALSE',
            5: 'DELETED'
        }

    def _success(self, code):
        return self.msgs[code]

    def _fail(self, code):
        return self.msgs[code]

    def get(self, **kwargs):
        if kwargs['key']:
            if kwargs['key'] in self.database:
                return self.database[kwargs['key']]
            else:
                return self._fail(2)
        else:
            return self._fail(-1)

    def set(self, **kwargs):
        if kwargs['key']:
            if kwargs['val']:
                self.database[kwargs['key']] = kwargs['val']
                return self._success(0)
            else:
                return self._fail(1)
        else:
            return self._fail(-1)

    def exists(self, **kwargs):
        if kwargs['key']:
            if kwargs['key'] in self.database:
                return self._success(3)
            else:
                return self._fail(4)
        else:
            return self._fail(-1)

    def delete(self, **kwargs):
        if kwargs['key']:
            if kwargs['key'] in self.database:
                del self.database[kwargs['key']]
                return self._success(5)
            else:
                return self._fail(2)
        else:
            return self._fail(-1)


class DataObjectMapping:
    def __init__(self, database=None):
        if database:
            self.db = database
        else:
            self.db = Database()
        self.mapping = {
            'get': self.db.get,
            'set': self.db.set,
            'exists': self.db.exists,
            'delete': self.db.delete
        }

    def mapping(self, cmd):
        if cmd not in self.mapping:
            raise 'Invalid cmd: %s' % cmd
        return self.mapping[cmd]


class CommandParser:
    def parse(self, input_string):
        tokens = input_string.strip().split()

        inputs = {}
        # case insensitive
        inputs['cmd'] = tokens[0].lower() if tokens else None
        inputs['key'] = tokens[1] if len(tokens) >= 2 else None
        inputs['val'] = tokens[2] if len(tokens) >= 3 else None
        return inputs


class KvMem:
    def execute(shellCommand):
        raise NotImplemented('Please implement execute.')


class SimpleKvMem(KvMem):
    def __init__(self):
        self.dom = DataObjectMapping()
        self.parser = CommandParser()

    def execute(self, shellCommand):
        inputs = self.parser.parse(shellCommand)
        db_exec = self.dom.mapping[inputs['cmd']]
        return db_exec(**inputs)



if __name__ == '__main__':
    km = SimpleKvMem()
    while True:
        shellCommand = input('-> ')
        if not shellCommand:
            break
        print(km.execute(shellCommand))