parser.py

OPERATORS = {
    ('OR', '||'): '||',
    ('AND', '&&'): '&&',
    ('<=>', ' '): '<=>',
}

class Parser(object):    
    @property
    def operator_reprs(self):
        for k in OPERATORS.keys():
            for r in k:
                yield r
     
    @property
    def operators(self):
        return OPERATORS.values()

    def resolve_operator(self, operator):
        for r, o in OPERATORS.items():
            if operator in r:
                return o
    
    def parse_expression(self, expr):
        expr = expr.replace('(', ' ( ')
        expr = expr.replace(')', ' ) ')
        tokens = expr.split(' ')
        return self.eval(tokens)

    def eval(self, tokens):
        open_brackets = 0
        pos = -1
        tree = None
        operator = self.resolve_operator('<=>')
        for i, t in enumerate(tokens):
            if t == '':
                continue
            elif t == '(':
                if open_brackets == 0:
                    pos = i
                open_brackets += 1
            elif t == ')':
                open_brackets -= 1
            if t in self.operator_reprs and open_brackets == 0:
                operator = self.resolve_operator(t)
            elif open_brackets == 0:
                if pos == -1:
                    if tree is None:
                        tree = t
                    else:
                        tree = (operator, tree, self.eval([t]))
                else:
                    sub_expr = tokens[pos+1:i]
                    if tree is None:
                        tree = self.eval(sub_expr)
                    else:
                        tree = (operator, tree, self.eval(sub_expr))
        return tree