Refactored to allow ConceptEvaluator

evaluators/PythonEvaluator.py

@@ -1,32 +1,32 @@
-from core.concept import ReturnValueConcept, ErrorConcept
-from evaluators.BaseEvaluator import BaseEvaluator
+from core.builtin_concepts import BuiltinConcepts, ParserResultConcept
+from evaluators.BaseEvaluator import OneReturnValueEvaluator
 from parsers.PythonParser import PythonNode
 import ast
-from core.sheerka import ReturnValue, Sheerka
 import logging
 
 log = logging.getLogger(__name__)
 
 
-class PythonEvaluator(BaseEvaluator):
+class PythonEvaluator(OneReturnValueEvaluator):
     def __init__(self):
         super().__init__("Python Evaluator", 50)
 
-    def matches(self, context, items):
-        return len(items) == 1 and isinstance(items[0].value, PythonNode)
+    def matches(self, context, return_value):
+        return return_value.status and \
+            isinstance(return_value.value, ParserResultConcept) and \
+            isinstance(return_value.value.value, PythonNode)
 
-    def eval(self, context, items):
+    def eval(self, context, return_value):
         sheerka = context.sheerka
-        node = items[0].value
-        if isinstance(node.ast, ast.Expression):
+        node = return_value.value.value
+        if isinstance(node.ast_, ast.Expression):
             try:
-                log.debug("Evaluating python expression")
-                compiled = compile(node.ast, "<string>", "eval")
+                log.debug(f"Evaluating python node {node}")
+                compiled = compile(node.ast_, "<string>", "eval")
                 evaluated = eval(compiled, {}, {"sheerka": context.sheerka})
-                concept = sheerka.new(ReturnValueConcept.NAME, body=evaluated)
-                return ReturnValue(self.name, True, concept)
+                return sheerka.ret(self.name, True, evaluated, parents=[return_value])
             except Exception as error:
-                error = sheerka.new(ErrorConcept.NAME, body=error)
-                return ReturnValue(self.name, False, error)
+                error = sheerka.new(BuiltinConcepts.ERROR, body=error)
+                return sheerka.ret(self.name, False, error, parents=[return_value])
         else:
             raise NotImplementedError()