python 自定义表达式解释器

def extract_subnode(expression):
    expression = f"({expression})"
    parentheses_stack = []
    groups = []
    last_char = None
    for loc, char in enumerate(expression):
        if char == '(' and last_char != '\\':
            parentheses_stack.append(loc)
        elif char == ')' and last_char != '\\':
            if len(parentheses_stack) == 0:
                raise Exception("左右括号不匹配")
            else:
                l = parentheses_stack.pop()
                groups.append((l,loc,expression[l+1:loc]))
        last_char = char
    if len(parentheses_stack) != 0:
        raise Exception("左右括号不匹配")
    return groups

class Expression:
    def __or__(self, other):
        return Or(self, other)
    def __and__(self, other):
        return And(self, other)
    def to_dict(self,):
        pass 
        
class Ops(Expression):
    def __init__(self, a, b, logic):
        self.a = a
        self.b = b
        self.logic = logic
    def __repr__(self):
        return "{}({},{})".format(self.logic, self.a, self.b)
    
    def to_dict(self,):
        return {"condition": self.logic, "logics": [self.a.to_dict(), self.b.to_dict()]}
    
class Or(Ops):
    def __init__(self, a, b):
        super(Or, self).__init__(a, b, "or")

class And(Ops):
    def __init__(self, a, b):
        super(And, self).__init__(a, b, "and")
        
import re
class Factor(Expression):
    subjects = ["识别对象A", "识别对象B", "识别对象C"]
    rule_types = ["识别方式1", "识别方式2", "识别方式3"]
    re_factor = re.compile(f"({'|'.join(subjects)})\s+({'|'.join(rule_types)})")
    re_subject = re.compile(f"({'|'.join(subjects)})")
    re_type = re.compile(f"({'|'.join(rule_types)})")
    re_exp = re.compile(f"({'|'.join(subjects)})\s+({'|'.join(rule_types)})\s+(.*)")

    def __init__(self, exp):
        self.raw_exp = exp
        self.subject = Factor.re_subject.findall(exp)[0]
        self.type = Factor.re_type.findall(exp)[0]
        self.subject = Factor.re_subject.findall(exp)[0]
        self.expression = Factor.re_exp.match(exp).group(3)
    
    def __repr__(self,):
        return self.raw_exp
    
    def to_dict(self,):
        return {"subject": self.subject, "type":self.type, "expression": self.expression}

    @staticmethod
    def valid_expression(expression):
        return len(Factor.re_factor.findall(expression)) == 1
    
def extract_logic(raw_expression):
    nodelist = extract_subnode(raw_expression)
    factors = list(filter(lambda x:Factor.valid_expression(x[2]), nodelist))
    factor_tokens = {f"factor_{i}": factors[i][2] for i in range(len(factors))}
    for token, exp in factor_tokens.items():
        raw_expression = raw_expression.replace(exp, token)
    raw_expression = raw_expression.replace("||", "|").replace("&&", "&")
    raw_expression = re.sub('(factor_[\d]+)', r'Factor(factor_tokens["\1"])', raw_expression)
    dic = eval(raw_expression).to_dict()
    return dic