refactored old code and bgun implementation on truth table

Author: HarrySu123

evaluation_function/evaluation.py

@@ -3,8 +3,11 @@
 
 from evaluation_function.domain.evaluators import *
 from evaluation_function.domain.formula import *
-from evaluation_function.parsing.tokenizer import *
-from evaluation_function.parsing.tree_builder import *
+
+from evaluation_function.parsing.parser import formula_parser
+
+
+from evaluation_function.parsing.tree_builder_error import BuildError
 
 
 def evaluation_function(
@@ -73,28 +76,10 @@ def evaluation_function(
     feedback   = None
     is_correct = False
 
-    # tokenize response
-    tokenizer = Tokenizer(response)
-    tokens = []
 
+    # parse response into Formula
     try:
-        while True:
-            token = tokenizer.next_token()
-            tokens.append(token)
-            if token.type == TokenType.EOF:
-                break
-    
-    except ValueError as e:
-        return Result(
-            is_correct=False,
-            feedback_items=[(ValueError, str(e))]
-        )
-
-
-    # parse tokens into Formula
-    try:
-        builder = TreeBuilder(tokens)
-        formula = builder.build()
+        formula = formula_parser(response)
 
     except BuildError as e:
         return Result(
@@ -104,33 +89,15 @@ def evaluation_function(
     except ValueError as e:
         return Result(
             is_correct=False,
-            feedback_items=[(BuildError, str(e))]
+            feedback_items=[(ValueError, str(e))]
         )
 
 
     if equivalence:
-        
-        answer_tokenizer = Tokenizer(answer)
-        answer_tokens = []
 
         # tokenise answer 
         try:
-            while True:
-                answer_token = answer_tokenizer.next_token()
-                answer_tokens.append(answer_token)
-                if answer_token.type == TokenType.EOF:
-                    break
-        
-        except ValueError as e:
-            return Result(
-                is_correct=False,
-                feedback_items=[(ValueError, str(e))]
-            )
-        
-        # parse answer tokens into Formula
-        try:
-            answer_builder = TreeBuilder(answer_tokens)
-            answer_formula = answer_builder.build()
+            answer_formula = formula_parser(answer)
 
         except BuildError as e:
             return Result(
@@ -140,7 +107,7 @@ def evaluation_function(
         except ValueError as e:
             return Result(
                 is_correct=False,
-                feedback_items=[(BuildError, str(e))]
+                feedback_items=[(ValueError, str(e))]
             )
 
         is_correct = EquivalenceEvaluator(formula, answer_formula).evaluate()

evaluation_function/parsing/parser.py

@@ -0,0 +1,21 @@
+
+from evaluation_function.domain.formula import *
+from evaluation_function.parsing.tokenizer import *
+from evaluation_function.parsing.tree_builder import *
+
+def formula_parser(input: str) -> Formula:
+
+    # tokenize input
+    tokenizer = Tokenizer(input)
+    tokens = []
+
+    token = Token()
+    while token.type != TokenType.EOF:
+        token = tokenizer.next_token()
+        tokens.append(token)
+    
+    # parse tokens into Formula
+    builder = TreeBuilder(tokens)
+    formula = builder.build()
+
+    return formula

evaluation_function/parsing/token.py

@@ -16,7 +16,7 @@ class TokenType(Enum):
 
 
 class Token:
-    def __init__(self, token_type: TokenType, value: str, position: int):
+    def __init__(self, token_type: TokenType = None, value: str = "", position: int = -1):
         self.type = token_type
         self.value = value
         self.position = position

evaluation_function/parsing/tree_builder.py

@@ -5,14 +5,7 @@
 from .expression_builder import ExpressionBuilder
 from .primary_builder import PrimaryBuilder
 from .binary_operator_builder import BinaryOperatorBuilder
-
-
-class BuildError(Exception):
-    def __init__(self, message: str, position: int):
-        self.message = message
-        self.position = position
-        super().__init__(f"{message} at position {position}")
-
+from .tree_builder_error import BuildError
 
 class TreeBuilder:
     def __init__(self, tokens: List[Token], expression_builder: Optional[ExpressionBuilder] = None):

evaluation_function/parsing/tree_builder_error.py

@@ -0,0 +1,5 @@
+class BuildError(Exception):
+    def __init__(self, message: str, position: int):
+        self.message = message
+        self.position = position
+        super().__init__(f"{message} at position {position}")

evaluation_function/preview.py

@@ -1,10 +1,9 @@
 from typing import Any
 from lf_toolkit.preview import Result, Params, Preview
 
-from evaluation_function.domain.evaluators import *
 from evaluation_function.domain.formula import *
-from evaluation_function.parsing.tokenizer import *
-from evaluation_function.parsing.tree_builder import *
+from evaluation_function.parsing.parser import formula_parser
+from evaluation_function.parsing.tree_builder_error import BuildError
 
 def preview_function(response: Any, params: Params) -> Result:
     """
@@ -30,25 +29,9 @@ def preview_function(response: Any, params: Params) -> Result:
     feedback   = None
     is_correct = False
 
-    # tokenize response
-    tokenizer = Tokenizer(response)
-    tokens = []
-
-    try:
-        while True:
-            token = tokenizer.next_token()
-            tokens.append(token)
-            if token.type == TokenType.EOF:
-                break
-    
-    except ValueError as e:
-        return Result(preview=Preview(feedback = str(e)))
-
-
-    # parse tokens into Formula
+    # parse response into Formula
     try:
-        builder = TreeBuilder(tokens)
-        formula = builder.build()
+        formula = formula_parser(response)
 
     except BuildError as e:
         return Result(preview=Preview(feedback = str(e)))

evaluation_function/truth_table/evaluate.py

@@ -0,0 +1,69 @@
+
+from evaluation_function.domain.formula import (
+    Formula,
+    Atom
+)
+
+
+from evaluation_function.domain.evaluators import _extract_atoms
+from evaluation_function.domain.formula import *
+from evaluation_function.parsing.parser import formula_parser
+
+from evaluation_function.parsing.tree_builder_error import BuildError
+
+
+# assume table sent through is of type list[list[str]]
+def evaluate(input: list[list[str]]) -> bool:
+
+    if len(input) == 0:
+        raise Exception("no input was given")
+    elif len(input) == 1:
+        raise Exception("Must provide names and its truth values")
+
+    # find the atoms of the formula
+    formulas = input[0]
+    existing_atoms = set()
+
+    for i in range(len(formulas)):
+        formula_string = formulas[i]
+        error_message = f"formula in column {i+1} incorrect: "
+
+        # parse tokens into Formula
+        try:
+            formula = formula_parser(formula_string)
+        
+        except BuildError as e:
+            raise Exception(error_message + str(e))
+        except ValueError as e:
+            raise Exception(error_message + str(e))
+
+        # formula is valid
+        
+        # if formula is an atom, keep track of it
+        if isinstance(formula, Atom):
+            existing_atoms.add(formula)
+        
+        # otherwise check all atoms in formula is to the left on the table (i.e all atoms in formula has been defined)
+        else:
+            current_atoms = _extract_atoms(formula)
+            
+            for atom in current_atoms:
+
+                # if an atom is undefined, erro
+                if atom not in existing_atoms:
+                    raise Exception(f"in column {i+1}, atom {atom} in formula {formula_string} is undefined")
+    
+    # all formula and its order in the table is valid
+
+    
+                
+        
+
+
+
+
+
+
+
+
+