import copy from enum import Enum from core.ast.visitors import UnreferencedNamesVisitor from core.builtin_concepts import BuiltinConcepts, ParserResultConcept from core.concept import ConceptParts, Concept from evaluators.BaseEvaluator import OneReturnValueEvaluator from parsers.PythonParser import PythonNode import ast import core.ast.nodes class PythonEvaluator(OneReturnValueEvaluator): NAME = "Python" """ Evaluate a Python node, ie, evaluate some Python code """ def __init__(self): super().__init__(self.NAME, [BuiltinConcepts.EVALUATION], 50) self.locals = {} 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, return_value): sheerka = context.sheerka node = return_value.value.value try: context.log(self.verbose_log, f"Evaluating python node {node}.", self.name) # Do not evaluate if the ast refers to a concept (leave it to ConceptEvaluator) if isinstance(node.ast_, ast.Expression) and isinstance(node.ast_.body, ast.Name): c = context.sheerka.get(node.ast_.body.id) if not context.sheerka.isinstance(c, BuiltinConcepts.UNKNOWN_CONCEPT): context.log(self.verbose_log, "It's a simple concept. Not for me.", self.name) not_for_me = context.sheerka.new(BuiltinConcepts.NOT_FOR_ME, body=node) return sheerka.ret(self.name, False, not_for_me, parents=[return_value]) my_locals = self.get_locals(context, node) context.log(self.verbose_log, f"locals={my_locals}", self.name) if isinstance(node.ast_, ast.Expression): context.log(self.verbose_log, "Evaluating using 'eval'.", self.name) compiled = compile(node.ast_, "", "eval") evaluated = eval(compiled, {}, my_locals) else: context.log(self.verbose_log, "Evaluating using 'exec'.", self.name) evaluated = self.exec_with_return(node.ast_, my_locals) context.log(self.verbose_log, f"{evaluated=}", self.name) return sheerka.ret(self.name, True, evaluated, parents=[return_value]) except Exception as error: context.log_error(self.verbose_log, error, self.name) error = sheerka.new(BuiltinConcepts.ERROR, body=error) return sheerka.ret(self.name, False, error, parents=[return_value]) def get_locals(self, context, node): my_locals = {"sheerka": context.sheerka} if context.obj: context.log(self.verbose_log, f"Concept '{context.obj}' is in context. Adding its properties to locals if any.", self.name) for prop_name, prop_value in context.obj.props.items(): if not isinstance(prop_value.value, Concept): my_locals[prop_name] = prop_value.value else: my_locals[prop_name] = context.sheerka.value(prop_value.value) node_concept = core.ast.nodes.python_to_concept(node.ast_) unreferenced_names_visitor = UnreferencedNamesVisitor(context.sheerka) unreferenced_names_visitor.visit(node_concept) for name in unreferenced_names_visitor.names: context.log(self.verbose_log, f"Resolving '{name}'.", self.name) if name in node.concepts: context.log(self.verbose_log, f"Using value from node.", self.name) concept = node.concepts[name] return_concept = False else: concept_key, concept_id, return_concept = self.resolve_name(context, name) if concept_key in my_locals: context.log(self.verbose_log, f"Using value from property.", self.name) continue context.log(self.verbose_log, f"Instantiating new concept.", self.name) concept = context.sheerka.new((concept_key, concept_id)) if context.sheerka.isinstance(concept, BuiltinConcepts.UNKNOWN_CONCEPT): context.log(self.verbose_log, f"'{concept_key}' is not a concept. Skipping.", self.name) continue context.log(self.verbose_log, f"Evaluating '{concept}'", self.name) with context.push(self.name, desc=f"Evaluating '{concept}'", obj=concept) as sub_context: sub_context.log_new(self.verbose_log) evaluated = context.sheerka.evaluate_concept(sub_context, concept, self.verbose_log) sub_context.add_values(return_values=evaluated) if evaluated.key == concept.key: my_locals[name] = evaluated if return_concept else \ evaluated.body if ConceptParts.BODY in evaluated.cached_asts else \ evaluated if self.locals: my_locals.update(self.locals) return my_locals def resolve_name(self, context, to_resolve): """ Try to match __C__concept_key__C__ or __C__concept_key__concept_id__C__ :param context: :param to_resolve: :return: """ if not to_resolve.startswith("__C__"): return to_resolve, None, False context.log(self.verbose_log, f"Resolving name '{to_resolve}'.", self.name) if len(to_resolve) >= 18 and to_resolve[:18] == "__C__USE_CONCEPT__": use_concept = True index = 18 else: use_concept = False index = 5 try: next_index = to_resolve.index("__", index) if next_index == index: context.log(self.verbose_log, f"Error: no key between '__'.", self.name) return None concept_key = to_resolve[index: next_index] except ValueError: context.log(self.verbose_log, f"Error: Missing trailing '__'.", self.name) return None if next_index == len(to_resolve) - 5: context.log(self.verbose_log, f"Recognized concept '{concept_key}'", self.name) return concept_key, None, use_concept index = next_index + 2 try: next_index = to_resolve.index("__", index) if next_index == index: context.log(self.verbose_log, f"Error: no id between '__'.", self.name) return None concept_id = to_resolve[index: next_index] except ValueError: context.log(self.verbose_log, f"Recognized concept '{concept_key}'.", self.name) return concept_key, None, use_concept context.log(self.verbose_log, f"Recognized concept '{concept_key}' (id='{concept_id}').", self.name) return concept_key, concept_id, use_concept @staticmethod def expr_to_expression(expr): expr.lineno = 0 expr.col_offset = 0 result = ast.Expression(expr.value, lineno=0, col_offset=0) return result def exec_with_return(self, code_ast, my_locals): init_ast = copy.deepcopy(code_ast) init_ast.body = code_ast.body[:-1] last_ast = copy.deepcopy(code_ast) last_ast.body = code_ast.body[-1:] exec(compile(init_ast, "", "exec"), {}, my_locals) if type(last_ast.body[0]) == ast.Expr: return eval(compile(self.expr_to_expression(last_ast.body[0]), "", "eval"), {}, my_locals) else: exec(compile(last_ast, "", "exec"), {}, my_locals)