written doc for dev and re-wrto how params are processed for evaluation_function

Author: HarrySu123

docs/dev.md

@@ -1,29 +1,49 @@
 # YourFunctionName
-*Brief description of what this evaluation function does, from the developer perspective*
 
-## Inputs
-*Specific input parameters which can be supplied when the `eval` command is supplied to this function.*
+This evaluation function checks if the inputted respons is a valid formula within Propositional Logic.
 
-## Outputs
-*Output schema/values for this function*
+Select the sort of evlauation you want to using the check box. Make sure to only select 1.
 
-## Examples
-*List of example inputs and outputs for this function, each under a different sub-heading*
 
-### Simple Evaluation
+## Inputs
 
-```python
+```json
 {
-  "example": {
-    "Something": "something"
+  "response":"<str>",
+  "answer":"<str>",
+  "params": {
+    "equivalence": "<bool>",
+    "tautology": "<bool>",
+    "satisfiability": "<bool>",
   }
 }
 ```
 
-```python
+### `equivalence`
+
+checks if response formula and answer formula are equivalent
+
+### `tautology`
+
+checks if response formula is a tautology
+
+### `satisfiability`
+
+checks if response formula is satisfiabiable
+
+## Outputs
+
+```json
 {
-  "example": {
-    "Something": "something"
-  }
+  "is_correct": "<bool>",
+  "feedback_items": "<str>"
 }
-```
+```
+
+### `is_correct`
+
+boolean of the correctness of response
+
+### `feedback_items`
+
+the list of errors that occurred in the evaluation process

evaluation_function/evaluation.py

@@ -143,9 +143,28 @@ def evaluation_function(
         )
 
 
-    # this can be "equivilance", "tautology", "satisfiability"
-    #potnetially can be switched with classes
-    action = params.get("action", None)
+    # check only one of "equivilance", "tautology", "satisfiability" is selected
+    
+    equivalence = params.get("equivalence", False)
+    tautology = params.get("tautology", False)
+    satisfiability = params.get("satisfiability", False)
+
+    #check that 1 and only 1 param is selected
+    if not (equivalence ^ tautology ^ satisfiability):
+
+        if not (equivalence or tautology or satisfiability):
+            #no params selected
+            return Result(
+                is_correct=False,
+                feedback_items=[("invalid param", "please select a param")]
+            )
+        
+        # more than one param selected
+        return Result(
+            is_correct=False,
+            feedback_items=[("invalid param", "please only select 1 param")]
+        )
+
 
     feedback   = None
     is_correct = False
@@ -179,15 +198,43 @@ def evaluation_function(
             feedback_items=[(BuildError, str(e))]
         )
 
-    #swtich on action
-    
-    match action:
-        case "tautology":
-            is_correct = TautologyEvaluator(formula).evaluate()
+
+    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()
+        
+        except BuildError as e:
+            return Result(
+                is_correct=False,
+                feedback_items=[(BuildError, str(e))]
+            )
+        
+        is_correct = EquivalenceEvaluator(formula, answer_formula).evaluate()
 
-        case "satisfiability":
-            is_correct = SatisfiabilityEvaluator(formula).evaluate()
 
-        # equivalence
+    elif tautology:
+        is_correct = TautologyEvaluator(formula).evaluate()
+    elif satisfiability:
+        is_correct = SatisfiabilityEvaluator(formula).evaluate()
 
     return Result(is_correct=is_correct)

evaluation_function/evaluation_test.py

@@ -31,15 +31,15 @@ def test_evaluation_default(self):
 
     def test_check_tautology(self):
 
-        response, answer, params = "p ∨ ¬p", "", {"action": "tautology"}
+        response, answer, params = "p ∨ ¬p", "", {"tautology": True}
 
         result = evaluation_function(response, answer, params).to_dict()
 
         self.assertTrue(result.get("is_correct"))
 
     def test_check_tautology_fail(self):
 
-        response, answer, params = "p ∧ ¬p", "", {"action": "tautology"}
+        response, answer, params = "p ∧ ¬p", "", {"tautology": True}
 
         result = evaluation_function(response, answer, params).to_dict()
 
@@ -48,16 +48,34 @@ def test_check_tautology_fail(self):
 
     def test_check_satisfiability(self):
 
-        response, answer, params = "p ∧ q", "", {"action": "satisfiability"}
+        response, answer, params = "p ∧ q", "", {"satisfiability": True}
 
         result = evaluation_function(response, answer, params).to_dict()
 
         self.assertTrue(result.get("is_correct"))
 
     def test_check_satisfiability_fail(self):
 
-        response, answer, params = "p ∧ ¬p", "", {"action": "satisfiability"}
+        response, answer, params = "p ∧ ¬p", "", {"satisfiability": True}
 
         result = evaluation_function(response, answer, params).to_dict()
 
         self.assertFalse(result.get("is_correct"))
+
+    
+    def test_check_equivalence(self):
+        
+        response, answer, params = "p ∧ q", "p ∧ (q ∨ q)", {"equivalence": True}
+
+        result = evaluation_function(response, answer, params).to_dict()
+
+        self.assertTrue(result.get("is_correct"))
+    
+    def test_check_equivalence_fail(self):
+        
+        response, answer, params = "p ∧ q", "p", {"equivalence": True}
+
+        result = evaluation_function(response, answer, params).to_dict()
+
+        self.assertFalse(result.get("is_correct"))
+