I can manage infinite recursion when building concept

tests/evaluators/EvaluatorTestsUtils.py

@@ -1,7 +1,10 @@
-from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts
+import ast
+
+from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts, ParserResultConcept
 from core.concept import Concept
 from evaluators.BaseEvaluator import BaseEvaluator
 from parsers.BaseParser import BaseParser
+from parsers.PythonParser import PythonNode
 
 reduced_requested = ReturnValueConcept("Sheerka", True, Concept(name=BuiltinConcepts.REDUCE_REQUESTED,
                                                                 key=BuiltinConcepts.REDUCE_REQUESTED))
@@ -12,7 +15,7 @@ def ret_val(value="value", who="who", status=True):
 
 
 def p_ret_val(value="value", parser="parser", status=True):
-    return ReturnValueConcept(BaseParser.PREFIX + parser, status, value)
+    return ReturnValueConcept(BaseParser.get_name(parser), status, value)
 
 
 def e_ret_val(value="value", evaluator="evaluator", status=True):
@@ -40,6 +43,24 @@ def e_ret_val_new(key, evaluator="evaluator", status=True, **kwargs):
     return e_ret_val(body, evaluator, status)
 
 
+def pr_ret_val(value, parser="parser", source=None):
+    """
+    ParserResult ReturnValue
+    eg: ReturnValue with a ParserResult
+    :param value:
+    :param parser:
+    :param source:
+    :return:
+    """
+    source = source or (value.name if isinstance(value, Concept) else "source")
+    parser_result = ParserResultConcept(BaseParser.get_name(parser), source=source, value=value)
+    return p_ret_val(parser_result, parser)
+
+
+def python_ret_val(source):
+    python_node = PythonNode(source, ast.parse(source, f"<source>", 'eval'))
+    return pr_ret_val(python_node, parser="Python", source=source)
+
 def new_concept(key, **kwargs):
     res = Concept(key=key, name=key, is_builtin=False, is_unique=False)
     for k, v in kwargs.items():

tests/evaluators/test_ConceptEvaluator.py

@@ -91,12 +91,10 @@ class TestAddConceptEvaluator(TestUsingMemoryBasedSheerka):
         assert result.value == "'some_other_value'"
 
     def test_i_cannot_recognize_a_concept_if_one_of_the_prop_is_unknown(self):
-        context = self.get_context()
+        sheerka, context, one, concept_plus = self.init_concepts(
+            "one",
+            Concept(name="a plus b").def_var("a", "one").def_var("b", "two"))
         context.protected_hints.add(BuiltinConcepts.EVAL_BODY_REQUESTED)
-        context.sheerka.test_only_add_in_cache(Concept(name="one").init_key())
-        concept_plus = context.sheerka.test_only_add_in_cache(Concept(name="a plus b")
-                                                              .def_var("a", "one")
-                                                              .def_var("b", "two").init_key())
 
         evaluator = ConceptEvaluator()
         item = self.pretval(concept_plus)