1 files changed, 32 insertions, 32 deletions

diff --git a/parser.py b/parser.py
index 1cad137..a9b2a46 100644
--- a/parser.py
+++ b/parser.py
@@ -14,17 +14,17 @@ class Node:
         return self.type == other.type and self.value == other.value
 
     def __repr__(self):
-        if self.type == LEFT_PARENTHESIS:
+        if self.type == TokenType.LEFT_PARENTHESIS:
             return "Node(LEFT_PARENTHESIS)"
-        if self.type == RIGHT_PARENTHESIS:
+        if self.type == TokenType.RIGHT_PARENTHESIS:
             return "Node(RIGHT_PARENTHESIS)"
-        if self.type == NUMBER:
+        if self.type == TokenType.NUMBER:
             return f"Node({self.value})"
-        if self.type == OPERATOR:
+        if self.type == TokenType.OPERATOR:
             return f"Node({self.subtype})"
-        if self.type == COMMA:
+        if self.type == TokenType.COMMA:
             return f"Node(COMMA)"
-        if self.type == SYMBOL:
+        if self.type == TokenType.SYMBOL:
             return f"Node(SYMBOL {self.value})"
         if self.type == FUNCALL:
             return f"Node(FUNCALL {self.value})"
@@ -36,11 +36,11 @@ def parse_parenthesis(tokens, start):
     depth = 0
     while True:
         token = tokens[end]
-        if token.type == RIGHT_PARENTHESIS:
+        if token.type == TokenType.RIGHT_PARENTHESIS:
             depth -= 1
-        if token.type == LEFT_PARENTHESIS:
+        if token.type == TokenType.LEFT_PARENTHESIS:
             depth += 1
-        if depth == 0 and token.type == RIGHT_PARENTHESIS:
+        if depth == 0 and token.type == TokenType.RIGHT_PARENTHESIS:
             break
         end += 1
     node = build_tree(tokens[start + 1: end])
@@ -52,18 +52,18 @@ def parse_args(tokens, start):
     depth = 0
     while True:
         token = tokens[end]
-        if token.type == RIGHT_PARENTHESIS:
+        if token.type == TokenType.RIGHT_PARENTHESIS:
             depth -= 1
-        if token.type == LEFT_PARENTHESIS:
+        if token.type == TokenType.LEFT_PARENTHESIS:
             depth += 1
-        if depth == 0 and token.type == RIGHT_PARENTHESIS:
+        if depth == 0 and token.type == TokenType.RIGHT_PARENTHESIS:
             break
         end += 1
 
     args = []
     arg = []
     for token in tokens[start + 1: end]:
-        if token.type != COMMA:
+        if token.type != TokenType.COMMA:
             arg.append(token)
         else:
             args.append(arg.copy())
@@ -75,35 +75,35 @@ def parse_args(tokens, start):
 
 
 def build_tree(tokens):
-    state = STATE_NAME
+    state = State.NAME
     i = 0
     current_node = None
     while i < len(tokens):
         token = tokens[i]
-        if state == STATE_OPERATOR and token.type == LEFT_PARENTHESIS:
+        if state == State.OPERATOR and token.type == TokenType.LEFT_PARENTHESIS:
             args = parse_args(tokens, i)
             current_node.type = FUNCALL
             current_node.value = (current_node.value, args)
-        elif token.type in [LEFT_PARENTHESIS, NUMBER, SYMBOL] or token.subtype == UNARY:
-            if token.type == LEFT_PARENTHESIS:
+        elif token.type in [TokenType.LEFT_PARENTHESIS, TokenType.NUMBER, TokenType.SYMBOL] or token.subtype == UNARY:
+            if token.type == TokenType.LEFT_PARENTHESIS:
                 node, i = parse_parenthesis(tokens, i)
-                state = STATE_NAME
-            elif token.type == NUMBER:
-                node = Node(NUMBER, value=token.value)
-                state = STATE_OPERATOR
-            elif token.type == SYMBOL:
-                node = Node(SYMBOL, value=token.value)
-                state = STATE_OPERATOR
+                state = State.NAME
+            elif token.type == TokenType.NUMBER:
+                node = Node(TokenType.NUMBER, value=token.value)
+                state = State.OPERATOR
+            elif token.type == TokenType.SYMBOL:
+                node = Node(TokenType.SYMBOL, value=token.value)
+                state = State.OPERATOR
             elif token.subtype == UNARY:
-                node = Node(OPERATOR, subtype=UNARY)
-                node.left = Node(OPERATOR, subtype=token.value)
-                state = STATE_NAME
+                node = Node(TokenType.OPERATOR, subtype=UNARY)
+                node.left = Node(TokenType.OPERATOR, subtype=token.value)
+                state = State.NAME
 
             if current_node is None:
                 current_node = node
-            elif current_node.type == NUMBER:
+            elif current_node.type == TokenType.NUMBER:
                 raise ValueError("Not a valid expression")
-            elif current_node.type == OPERATOR:
+            elif current_node.type == TokenType.OPERATOR:
                 if current_node.left is None:
                     current_node.left = node
                     node.parent = current_node
@@ -113,11 +113,11 @@ def build_tree(tokens):
                     current_node = node
                 else:
                     raise ValueError("Not a valid expression")
-        elif token.type == OPERATOR:
+        elif token.type == TokenType.OPERATOR:
             node = Node(token.type, subtype=token.subtype, value=token.value)
             if current_node is None:
                 raise ValueError("Not a valid expression")
-            elif current_node.type in [NUMBER, OPERATOR, FUNCALL]:
+            elif current_node.type in [TokenType.NUMBER, TokenType.OPERATOR, FUNCALL]:
                 while current_node.parent is not None:
                     if PRECEDENCE[current_node.parent.subtype] < PRECEDENCE[node.subtype]:
                         node.parent = current_node.parent
@@ -131,7 +131,7 @@ def build_tree(tokens):
             else:
                 print(current_node, token)
                 raise ValueError("Not a valid expression")
-            state = STATE_NAME
+            state = State.NAME
         i += 1
 
     while current_node.parent is not None: