Placed consts in classes.

3 files changed, 64 insertions, 59 deletions

diff --git a/consts.py b/consts.py
index 5bf3fdd..86a8eef 100644
--- a/consts.py
+++ b/consts.py
@@ -1,7 +1,12 @@
-STATE_OPERATOR, STATE_NAME, *_ = range(100)
-(
-    LEFT_PARENTHESIS, RIGHT_PARENTHESIS, NUMBER, OPERATOR, SEMICOLON, COMMA, SYMBOL, *_
-) = range(100)
+class State:
+    OPERATOR, NAME, *_ = range(100)
+
+
+class TokenType:
+    (
+        LEFT_PARENTHESIS, RIGHT_PARENTHESIS, NUMBER, OPERATOR, SEMICOLON, COMMA, SYMBOL, *_
+    ) = range(100)
+
 
 UNARY = "unary"
 FUNCALL = "funcall"
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:
diff --git a/tokenizer.py b/tokenizer.py
index cad2752..13b824a 100644
--- a/tokenizer.py
+++ b/tokenizer.py
@@ -15,17 +15,17 @@ class Token:
         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 "Token(LEFT_PARENTHESIS)"
-        if self.type == RIGHT_PARENTHESIS:
+        if self.type == TokenType.RIGHT_PARENTHESIS:
             return "Token(RIGHT_PARENTHESIS)"
-        if self.type == NUMBER:
+        if self.type == TokenType.NUMBER:
             return f"Token({self.value})"
-        if self.type == OPERATOR:
+        if self.type == TokenType.OPERATOR:
             return f"Token({self.subtype})"
-        if self.type == COMMA:
+        if self.type == TokenType.COMMA:
             return f"Token(COMMA)"
-        if self.type == SYMBOL:
+        if self.type == TokenType.SYMBOL:
             return f"Token(SYMBOL {self.value})"
     __str__ = __repr__
 
@@ -53,38 +53,38 @@ def parse_symbol(line, start):
 
 
 def tokenize(line):
-    state = STATE_NAME
+    state = State.NAME
 
     tokens = []
     i = 0
     while i < len(line):
         char = line[i]
         if char == "(":
-            tokens.append(Token(LEFT_PARENTHESIS, None))
-            state = STATE_NAME
+            tokens.append(Token(TokenType.LEFT_PARENTHESIS, None))
+            state = State.NAME
         elif char == ")":
-            tokens.append(Token(RIGHT_PARENTHESIS, None))
-            state = STATE_OPERATOR
+            tokens.append(Token(TokenType.RIGHT_PARENTHESIS, None))
+            state = State.OPERATOR
         elif char == ",":
-            tokens.append(Token(COMMA, None))
-            state = STATE_NAME
+            tokens.append(Token(TokenType.COMMA, None))
+            state = State.NAME
         elif char in OPERATOR_CHARS:
-            if state == STATE_OPERATOR:
+            if state == State.OPERATOR:
                 val, i = parse_operator(line, i)
-                tokens.append(Token(OPERATOR, subtype=val))
-                state = STATE_NAME
-            elif state == STATE_NAME:
+                tokens.append(Token(TokenType.OPERATOR, subtype=val))
+                state = State.NAME
+            elif state == State.NAME:
                 val, i = parse_operator(line, i)
-                tokens.append(Token(OPERATOR, subtype=UNARY, value=val))
-                state = STATE_NAME
+                tokens.append(Token(TokenType.OPERATOR, subtype=UNARY, value=val))
+                state = State.NAME
         elif char in NUMBER_CHARS:
             val, i = parse_number(line, i)
-            tokens.append(Token(NUMBER, val))
-            state = STATE_OPERATOR
+            tokens.append(Token(TokenType.NUMBER, val))
+            state = State.OPERATOR
         elif char in SYMBOL_CHARS:
             val, i = parse_symbol(line, i)
-            tokens.append(Token(SYMBOL, val))
-            state = STATE_OPERATOR
+            tokens.append(Token(TokenType.SYMBOL, val))
+            state = State.OPERATOR
         elif char != " ":
             raise ValueError("Line is not a valid expression")
         i += 1