Coding: check transactions against rules

OPS = {
    ">": lambda a, b: a > b,
    "<": lambda a, b: a < b,
    ">=": lambda a, b: a >= b,
    "<=": lambda a, b: a <= b,
    "==": lambda a, b: a == b,
    "!=": lambda a, b: a != b,
}


# Part 1: one condition, like "amount > 1000".
class Condition:
    def __init__(self, field, op, value):
        self.field, self.op, self.value = field, op, value

    def matches(self, txn):
        if self.field not in txn:
            return False
        actual = txn[self.field]
        if isinstance(self.value, str) != isinstance(actual, str):
            return False  # never compare a number with a word
        return OPS[self.op](actual, self.value)


# Part 2: two rules joined by AND or OR.
class And:
    def __init__(self, left, right):
        self.left, self.right = left, right

    def matches(self, txn):
        return self.left.matches(txn) and self.right.matches(txn)


class Or:
    def __init__(self, left, right):
        self.left, self.right = left, right

    def matches(self, txn):
        return self.left.matches(txn) or self.right.matches(txn)


def tokenize(text):
    # Pad brackets with spaces so "(amount > 5)" splits cleanly.
    return text.replace("(", " ( ").replace(")", " ) ").split()


def parse_value(token):
    if token[0] in ("'", '"'):
        return token[1:-1]
    try:
        return float(token)
    except ValueError:
        return token


class Parser:
    def __init__(self, text):
        self.tokens = tokenize(text)
        self.pos = 0

    def peek(self):
        return self.tokens[self.pos] if self.pos < len(self.tokens) else None

    def take(self):
        token = self.peek()
        if token is None:
            raise ValueError("rule ended early")
        self.pos += 1
        return token

    def parse(self):
        rule = self.expression()
        if self.peek() is not None:
            raise ValueError("unexpected " + self.peek())
        return rule

    # expression = term (AND|OR term)*, read left to right with no precedence
    def expression(self):
        rule = self.term()
        while self.peek() is not None and self.peek().upper() in ("AND", "OR"):
            joiner = self.take().upper()
            right = self.term()
            rule = And(rule, right) if joiner == "AND" else Or(rule, right)
        return rule

    # term = ( expression ) | field op value
    def term(self):
        if self.peek() == "(":  # Part 3: brackets
            self.take()
            rule = self.expression()
            if self.take() != ")":
                raise ValueError("missing )")
            return rule
        field, op, value = self.take(), self.take(), self.take()
        if op not in OPS:
            raise ValueError("unknown operator " + op)
        return Condition(field, op, parse_value(value))


def check(transactions, rule_texts):
    # Parse every rule once, up front, so a bad rule fails fast.
    rules = [(text, Parser(text).parse()) for text in rule_texts]
    results = []
    for txn in transactions:
        hit = next((text for text, rule in rules if rule.matches(txn)), None)
        results.append(("DENY", hit) if hit else ("ACCEPT", None))
    return results