PLY issue

import ply.yacc as yacc
from lex_rule import tokens

from rule_AST import *


precedence = [
    ('left', 'IMPLIES'),
    ('left', 'XOR', 'XNOR'),
    ('left', 'OR', 'NOR'),
    ('left', 'AND', 'NAND'),
    ('nonassoc', 'IN', 'NIN', 'CONTAINS', 'NCONTAINS', 'SUBSET', 'SUPSET', 'NSUBS', 'NSUPS', 'SSUBS', 'SSUPS', 'NSSUBS',
     'NSSUPS'),
    ('nonassoc', 'EQ', 'NEQ', 'GT', 'LT', 'GTE', 'LTE'),
    ('left', 'UNION', 'INTERSECTION', 'SETSDIFF', 'SETDIFF'),
    ('left', 'PLUS', 'MINUS', 'PLUSMINUS'),
    ('left', 'MUL', 'DIV', 'MOD'),
    ('right', 'NOT'),
    # ('left', 'CONJ'),
    ('right', 'UPLUS', 'UMINUS', 'UPM'),
    ('right', 'EXP'),
    ('left', 'IMAG', 'COIMAG', 'DUAL'),
    ('left', 'INDEX'),
    ('left', 'FUNC')
]


def p_op_binop(p):
    """op : expression PLUS expression
          | expression MINUS expression
          | expression PLUSMINUS expression
          | expression MUL expression
          | expression DIV expression
          | expression MOD expression
          | expression EXP expression
          | expression EQ expression
          | expression NEQ expression
          | expression GT expression
          | expression LT expression
          | expression GTE expression
          | expression LTE expression
          | expression AND expression
          | expression OR expression
          | expression XOR expression
          | expression NAND expression
          | expression NOR expression
          | expression XNOR expression
          | expression IMPLIES expression
          | expression UNION expression
          | expression INTERSECTION expression
          | expression SETSDIFF expression
          | expression SETDIFF expression
          | expression IN expression
          | expression CONTAINS expression
          | expression SUBSET expression
          | expression SUPSET expression
          | expression FUNC expression
          """

    p[0] = BinOp_In_Exp(p[2], p[1], p[3])


def p_op_notmember(p):
    """op : expression SET_NOT IN expression %prec NIN
          | expression SET_NOT CONTAINS expression %prec NCONTAINS"""

    p[0] = BinOp_In_Exp('not '+p[3], p[1], p[4])


def p_op_notset(p):
    """op : expression SET_NOT SUBSET expression %prec NSUBS
          | expression SET_NOT SUPSET expression %prec NSUPS"""

    p[0] = BinOp_In_Exp('not '+p[3], p[1], p[4])


def p_op_strictset(p):
    """op : expression STRICT SUBSET expression %prec SSUBS
          | expression STRICT SUPSET expression %prec SSUPS"""

    p[0] = BinOp_In_Exp('strict '+p[3], p[1], p[4])


def p_op_notstrictset(p):
    """op : expression SET_NOT STRICT SUBSET expression %prec NSSUBS
          | expression SET_NOT STRICT SUPSET expression %prec NSSUPS"""

    p[0] = BinOp_In_Exp('not strict '+p[4], p[1], p[5])


def p_op_binop_postcircum(p):
    """op : expression OBRACK expression CBRACK %prec INDEX"""

    p[0] = BinOp_PostCircum_Exp(p[2], p[4], p[1], p[3])


def p_op_unop_pre(p):
    """op : MINUS expression %prec UMINUS
          | PLUS expression %prec UPLUS
          | PLUSMINUS expression %prec UPM
          | NOT expression"""

    p[0] = UnOp_Pre_Exp(p[1], p[2])


def p_op_unop_post(p):
    """op : expression IMAG
          | expression COIMAG
          | expression DUAL"""
          # | expression MUL %prec CONJ"""

    p[0] = UnOp_Post_Exp(p[2], p[1])


def p_list_start(p):
    """list : expression SEP"""

    p[0] = [p[1]]


def p_list_concat(p):
    """list : list expression SEP"""

    p[0] = p[1]+[p[2]]


def p_list_end(p):
    """list : list expression"""

    p[0] = p[1]+[p[2]]


def p_apply(p):
    """apply : scalar OPAREN expression CPAREN
             | scalar OPAREN list CPAREN
             | expression OPAREN expression CPAREN
             | expression OPAREN list CPAREN"""

    if type(p[3]) == list:
        p[0] = ApplyExp(p[1], *p[3])
    else:
        p[0] = ApplyExp(p[1], p[3])


def p_num(p):
    """num : NUM"""
    p[0] = NumExp(p[1])


def p_string(p):
    """string : STRING"""
    p[0] = StringExp(p[1])


def p_name(p):
    """name : NAME"""
    p[0] = NameExp(p[1])


def p_scalar(p):
    """scalar : num
              | string
              | name"""

    p[0] = p[1]


def p_value_litset(p):
    """value : OBRACE list CBRACE"""

    p[0] = LiteralSetExp({v for v in p[2]})


def p_value_emptyset(p):
    """value : OBRACE CBRACE"""

    p[0] = LiteralSetExp(set())


def p_value_setbuild(p):
    """value : OBRACE expression COLON name IN expression
             | OBRACE expression COLON expression CONTAINS name"""

    if p[5] == 'in':
        p[0] = BuildSetExp(p[2], p[4], p[6])

    elif p[5] == 'contains':
        p[0] = BuildSetExp(p[2], p[6], p[4])


def p_value_litlist(p):
    """value : OBRACK list CBRACK"""

    p[0] = LiteralListExp(p[2])


def p_value_emptylist(p):
    """value : OBRACK CBRACK"""

    p[0] = LiteralListExp([])


def p_group(p):
    """group : OPAREN expression CPAREN"""

    p[0] = p[2]


def p_expression_main(p):
    """expression : scalar
                  | group
                  | op
                  | apply
                  | value"""

    p[0] = p[1]


def p_error(p):  # Gets called with p=None
    print('Syntax Error: '+repr(p))

parser = yacc.yacc(tabmodule='tm')

if __name__ == '__main__':
    while True:
        inp = input('Expression: ')  # I enter "[]"
        if inp == '/EXIT':
            break
        else:
            out = parser.parse(inp)
            print(repr(out))