Python Генерировать правдивость из выражения, содержащего числовое значение и компараторы

Я нашел решение проблемы, мне просто нужно было ограничить использование, чтобы числовое значение не заканчивалось справа от операции, а также ограничить возможность с точки зрения операторов.

import ast
import operator
from itertools import product

class OperatorError(Exception):
    pass

class Expr():

    BOOLOP_SYMBOLS = (
        ast.And,
        ast.Or
    )

    UNARYOP_SYMBOLS = (
        ast.Not
    )

    BINOP_SYMBOLS = (
        ast.BitAnd,
        ast.BitXor,
        ast.Pow
    )

    CMPOP_SYMBOLS = (
        ast.Eq,
        ast.Gt,
        ast.GtE,
        ast.Lt,
        ast.LtE,
        ast.NotEq
    )

    def __init__(self, expr):
        self.tree = ast.parse(expr)
        self.expr=expr
        self.vars = self.SyntaxChecker().visit(self.tree)
        self.tt = self.generateTruthTable()

    def generateTruthTable(self):
        NO_GLOBALS = {'__builtins__': {}}
        truthtable=dict()
        for i, vals in enumerate(product([True,False],repeat=len(self.vars.keys()))):
            truthtable[i] = dict()
            vals_convert=[]
            for j,k in enumerate(self.vars.iterkeys()):
                vals_convert.append(self.vars[k][vals[j]])
            truthtable[i]['inputs'] = dict(zip(self.vars.keys(), vals_convert))
            truthtable[i]['expectation'] = eval(self.expr, NO_GLOBALS, truthtable[i]['inputs'])
        return truthtable

    class SyntaxChecker(ast.NodeVisitor):

        def visit_Module(self, module):
            self.vars = dict()
            self.generic_visit(module)
            return self.vars

        def visit_Expr(self, expr):
            return self.visit(expr.value)

        def visit_BoolOp(self, boolop):
            if isinstance(boolop.op, Expr.BOOLOP_SYMBOLS):
                left,right = map(self.visit, boolop.values)
                return [left, right]
            else:
                raise OperatorError(Expr.BOOLOP_SYMBOLS[boolop.op] + ' is not supported.')

        def visit_BinOp(self, binop):
            if isinstance(binop.op, Expr.BINOP_SYMBOLS):
                left , right = map(self.visit, [binop.left, binop.right])
                if isinstance(binop.op, ast.BitAnd):
                    self.vars[left] = {True: right, False: 0}
                if isinstance(binop.op, ast.BitXor):
                    self.vars[left] = {True: 0, False: right}
                if isinstance(binop.op, ast.Pow):
                    return left ** right
            else:
                raise OperatorError(Expr.BINOP_SYMBOLS[binop.op] + ' is not supported.')

        def visit_Compare(self, cmpop):
            if isinstance(cmpop.ops[0], Expr.CMPOP_SYMBOLS):
                left = self.visit(cmpop.left)
                right = self.visit(cmpop.comparators[0])
                if isinstance(cmpop.ops[0], ast.Gt):
                    self.vars[left] = {True: right + 1, False: right - 1}
                elif isinstance(cmpop.ops[0], ast.GtE):
                    self.vars[left] = {True: right, False: right - 1}
                elif isinstance(cmpop.ops[0], ast.Lt):
                    self.vars[left] = {True: right-1, False: right + 1}
                elif isinstance(cmpop.ops[0], ast.LtE):
                    self.vars[left] = {True: right, False: right + 1}
                elif isinstance(cmpop.ops[0], ast.Eq):
                    self.vars[left] = {True: right, False: right + 1}
                elif isinstance(cmpop.ops[0], ast.NotEq):
                    self.vars[left] = {True: right + 1, False: right}
            else:
                raise OperatorError(Expr.CMPOP_SYMBOLS[cmpop.ops] + ' is not supported.')

        def visit_UnaryOp(self, unaryop):
            if isinstance(unaryop.op, Expr.UNARYOP_SYMBOLS):
                right= self.visit(unaryop.operand)
                self.vars[right] = {True: False, False: True}
            else:
                raise OperatorError(Expr.UNARYOP_SYMBOLS[unaryop.op] + ' is not supported.')

        def visit_Num(self, num):
            return num.n

        def visit_Name(self, node):
            self.vars[node.id] = {True: True, False: False}
            return node.id

с примером:

(а ‹ 10) и (с == 5)

Я могу сгенерировать следующий вывод:

{ 0: {'входы': {'a': 9, 'c': 5}, 'ожидание': True}, 1: {'входы': {'a': 9, 'c': 6}, 'ожидание': False}, 2: {'входы': {'a': 11, 'c': 5}, 'ожидание': False}, 3: {'входы': {'a': 11, ' c': 6}, 'ожидание': False} }

не стесняйтесь предлагать любые улучшения этого решения.