I can manage infinite recursion when building concept

tests/core/test_ExecutionContext.py

@@ -1,4 +1,4 @@
-from core.builtin_concepts import BuiltinConcepts
+from core.builtin_concepts_ids import BuiltinConcepts
 from core.concept import Concept
 from core.sheerka.ExecutionContext import ExecutionContext
 from core.sheerka.services.SheerkaMemory import SheerkaMemory

tests/core/test_SheerkaAdmin.py

@@ -1,5 +1,3 @@
-from core.builtin_concepts import BuiltinConcepts
-
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
 
 

tests/core/test_SheerkaEvaluateConcept.py

@@ -1,12 +1,17 @@
+from dataclasses import dataclass
+
 import pytest
 from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept, ParserResultConcept
 from core.concept import Concept, DoNotResolve, ConceptParts, InfiniteRecursionResolved, CB, NotInit, \
-    concept_part_value
+    concept_part_value, DEFINITION_TYPE_DEF
 from core.sheerka.services.SheerkaEvaluateConcept import SheerkaEvaluateConcept
 from core.sheerka.services.SheerkaMemory import SheerkaMemory
-from parsers.PythonParser import PythonNode
+from parsers.BaseParser import BaseParser
+from parsers.PythonParser import PythonNode, PythonParser
 
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
+from tests.evaluators.EvaluatorTestsUtils import pr_ret_val, python_ret_val
+
 
 
 class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
@@ -709,7 +714,7 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
         assert sheerka.isinstance(evaluated, BuiltinConcepts.CHICKEN_AND_EGG)
         assert evaluated.body == {foo, bar, baz, qux}
 
-    def test_i_can_detect_auto_recursion(self):
+    def test_i_can_detect_infinite_recursion(self):
         sheerka, context, foo = self.init_concepts(
             Concept("foo", body="foo"),
             eval_body=True
@@ -863,11 +868,11 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
         service.initialize_concept_asts(context, concept)
         assert service.compute_metadata_to_eval(context, concept) == ["#where#"]
 
-        concept = Concept("foo", where="where a").def_var("a")
+        concept = Concept("foo", where="a").def_var("a")
         service.initialize_concept_asts(context, concept)
         assert service.compute_metadata_to_eval(context, concept) == ["variables", "#where#"]
 
-        concept = Concept("foo", where="where self")
+        concept = Concept("foo", where="self")
         service.initialize_concept_asts(context, concept)
         assert service.compute_metadata_to_eval(context, concept) == ["#body#", "#where#"]
 
@@ -925,6 +930,53 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
         res = sheerka.evaluate_concept(context, foo, eval_body=True)
         assert res.body == "Print return values"
 
+    def test_i_can_manage_python_concept_infinite_recursion_when_initializing_ast(self):
+        sheerka, context, foo = self.init_concepts(Concept("a + b", body="a + b").def_var("a").def_var("b"))
+        evaluator = SheerkaEvaluateConcept(sheerka)
+
+        evaluator.initialize_concept_asts(context, foo)
+        res = foo.get_compiled()["#body#"]
+
+        assert len(res) == 1
+        assert sheerka.isinstance(res[0], BuiltinConcepts.RETURN_VALUE)
+        assert res[0].who == BaseParser.get_name(PythonParser.NAME)
+
+        # TODO validate that a rule is created
+
+    def test_can_detect_recursive_definition_with_exact_concept(self):
+        sheerka, context, foo = self.init_concepts("foo")
+        evaluator = SheerkaEvaluateConcept(sheerka)
+
+        # 'def concept foo as foo'
+        return_values = [pr_ret_val(foo, parser="ExactConcept"), python_ret_val("foo")]
+
+        res = evaluator.get_recursive_definitions(foo, return_values)
+
+        assert list(res) == [BaseParser.get_name("ExactConcept")]
+
+    def test_i_can_detect_when_no_recursive_definition(self):
+        sheerka, context, foo, bar = self.init_concepts("foo", "bar")
+        evaluator = SheerkaEvaluateConcept(sheerka)
+
+        # 'def concept foo as bar'
+        return_values = [pr_ret_val(bar, parser="ExactConcept"), python_ret_val("foo")]
+
+        res = evaluator.get_recursive_definitions(foo, return_values)
+
+        assert list(res) == []
+
+    def test_i_can_detect_when_no_recursive_definition2(self):
+        sheerka, context, q = self.init_concepts(
+            Concept("q", definition="q ?", definition_type=DEFINITION_TYPE_DEF).def_var("q"))
+        evaluator = SheerkaEvaluateConcept(sheerka)
+
+        # i dunno how to construct the return value
+        return_values = [pr_ret_val(q, parser="ExactConcept")]
+
+        res = evaluator.get_recursive_definitions(q, return_values)
+
+        assert list(res) == []
+
     # I cannot implement value cache for now
     # def test_values_when_no_variables_are_computed_only_once(self):
     #     sheerka, context, foo = self.init_concepts(Concept("foo", body="10"))

tests/core/test_SheerkaSetsManager.py

@@ -204,8 +204,10 @@ class TestSheerkaSetsManager(TestUsingMemoryBasedSheerka):
         service.add_concepts_to_set(context, [one, two, twenty, twenties], number)
         assert sheerka.isinset(twenties, number)
 
-        twenty_one = sheerka.evaluate_user_input("twenty one", "")[0].body
-        assert sheerka.isinset(twenty_one, number)
+        res = sheerka.evaluate_user_input("twenty one", "")
+        assert len(res) == 1
+        assert res[0].status
+        assert sheerka.isinset(res[0].body, number)
 
     def test_a_concept_can_be_in_multiple_sets(self):
         sheerka, context, foo, all_foo, all_bar = self.init_concepts(

tests/core/test_sheerka.py

@@ -1,7 +1,8 @@
 import os
 
 import pytest
-from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept, UserInputConcept, AllBuiltinConcepts
+from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept, UserInputConcept
+from core.builtin_concepts_ids import AllBuiltinConcepts
 from core.concept import Concept, PROPERTIES_TO_SERIALIZE, ConceptParts, NotInit
 from core.sheerka.Sheerka import Sheerka, BASE_NODE_PARSER_CLASS
 from core.sheerka.services.SheerkaConceptManager import SheerkaConceptManager

tests/core/test_sheerka_call_evaluators.py

@@ -72,8 +72,10 @@ class EvaluatorOneWithPriority15(EvaluatorOneWithPriority):
 
 
 class EvaluatorOneWithPriority20(EvaluatorOneWithPriority):
-    def __init__(self):
+    def __init__(self, enabled=None):
         super().__init__("priority20", 20)
+        if enabled is not None:
+            self.enabled = enabled
 
 
 class EvaluatorAllWithPriority(AllReturnValueEvaluatorForTestingPurpose):
@@ -87,8 +89,8 @@ class EvaluatorAllWithPriority10(EvaluatorAllWithPriority):
 
 
 class EvaluatorAllWithPriority15(EvaluatorAllWithPriority):
-    def __init__(self):
-        super().__init__("all_priority15", 15)
+    def __init__(self, priority=15):
+        super().__init__("all_priority15", priority)
 
 
 class EvaluatorAllWithPriority20(EvaluatorAllWithPriority):
@@ -238,6 +240,12 @@ class EvaluatorOneDoNotModifyExecutionFlow(EvaluatorOneWithPriority):
         return return_value
 
 
+class DisabledEvaluatorOneWithPriority90(EvaluatorOneWithPriority):
+    def __init__(self):
+        super().__init__("disabled90", 90)
+        self.enabled = False
+
+
 class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
 
     @classmethod
@@ -246,6 +254,127 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
         # Ask for a new one
         TestUsingMemoryBasedSheerka.singleton_instance = None
 
+    def test_i_can_get_evaluators_when_context_is_not_altered(self):
+        sheerka, context = self.init_concepts()
+        sheerka.evaluators = [
+            EvaluatorOneWithPriority20,
+            EvaluatorAllWithPriority15,
+            EvaluatorOnePreEvaluation,  # wrong step
+            DisabledEvaluatorOneWithPriority90,  # disabled,
+        ]
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_evaluators()
+
+        groups, sorted_priorities = service.get_evaluators(context, BuiltinConcepts.EVALUATION)
+        assert groups == {20: [EvaluatorOneWithPriority20()], 15: [EvaluatorAllWithPriority15()]}
+        assert sorted_priorities == [20, 15]
+
+    def test_i_can_get_selected_evaluators(self):
+        sheerka, context = self.init_concepts()
+        sheerka.evaluators = [
+            EvaluatorOneWithPriority20,
+            EvaluatorAllWithPriority15,
+            EvaluatorOnePreEvaluation,  # wrong step
+            DisabledEvaluatorOneWithPriority90,  # disabled
+            EvaluatorOneWithPriority15,  # not selected
+        ]
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_evaluators()
+        evaluators_names = ["priority20", "all_priority15", "preEval", "disabled90"]
+        context.preprocess_evaluators = evaluators_names
+
+        groups, sorted_priorities = service.get_evaluators(context, BuiltinConcepts.EVALUATION)
+        assert groups == {20: [EvaluatorOneWithPriority20()], 15: [EvaluatorAllWithPriority15()]}
+        assert sorted_priorities == [20, 15]
+
+        key = BuiltinConcepts.EVALUATION + "|" + "|".join(evaluators_names)
+        assert key in service.grouped_evaluators_cache
+        groups, sorted_priorities = service.grouped_evaluators_cache[key]
+        assert groups == {20: [EvaluatorOneWithPriority20()], 15: [EvaluatorAllWithPriority15()]}
+        assert sorted_priorities == [20, 15]
+
+    def test_i_can_get_altered_evaluators(self):
+        sheerka, context = self.init_concepts()
+        sheerka.evaluators = [
+            EvaluatorOneWithPriority20,
+            EvaluatorAllWithPriority15,
+            EvaluatorOnePreEvaluation,  # wrong step
+            DisabledEvaluatorOneWithPriority90,  # always disabled
+            EvaluatorOneWithPriority15,  # dynamically disabled
+        ]
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_evaluators()
+        context.add_preprocess(BaseEvaluator.get_name("priority15"), enabled=False)
+        context.add_preprocess(BaseEvaluator.get_name("all_priority15"), priority=99)
+
+        groups, sorted_priorities = service.get_evaluators(context, BuiltinConcepts.EVALUATION)
+        assert groups == {20: [EvaluatorOneWithPriority20()], 99: [EvaluatorAllWithPriority15(99)]}
+        assert sorted_priorities == [99, 20]
+        service.undo_preprocess()
+
+        # make sure that the result in not kept in cache
+        another_context = self.get_context(sheerka)
+        another_context.add_preprocess(BaseEvaluator.get_name("all_priority15"), priority=50)
+
+        groups, sorted_priorities = service.get_evaluators(another_context, BuiltinConcepts.EVALUATION)
+        assert groups == {20: [EvaluatorOneWithPriority20()],
+                          15: [EvaluatorOneWithPriority15()],
+                          50: [EvaluatorAllWithPriority15(50)]}
+        assert sorted_priorities == [50, 20, 15]
+
+    def test_i_can_get_altered_and_selected_evaluators(self):
+        sheerka, context = self.init_concepts()
+        sheerka.evaluators = [
+            EvaluatorOneWithPriority20,
+            EvaluatorAllWithPriority15,
+            EvaluatorOnePreEvaluation,  # wrong step
+            DisabledEvaluatorOneWithPriority90,  # always disabled
+            EvaluatorOneWithPriority15,  # dynamically disabled
+        ]
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_evaluators()
+        evaluators_names = ["all_priority15", "preEval", "disabled90", "priority15"]
+        context.preprocess_evaluators = evaluators_names
+        context.add_preprocess(BaseEvaluator.get_name("priority15"), enabled=False)
+        context.add_preprocess(BaseEvaluator.get_name("all_priority15"), priority=99)
+        context.add_preprocess(BaseEvaluator.get_name("priority20"), priority=98)  # not selected
+
+        groups, sorted_priorities = service.get_evaluators(context, BuiltinConcepts.EVALUATION)
+        assert groups == {99: [EvaluatorAllWithPriority15(99)]}
+        assert sorted_priorities == [99]
+
+        key = BuiltinConcepts.EVALUATION + "|" + "|".join(evaluators_names)
+        assert key not in service.grouped_evaluators_cache
+
+    def test_i_can_revert_back_evaluators_alterations(self):
+        sheerka, context = self.init_concepts()
+        sheerka.evaluators = [
+            EvaluatorOneWithPriority20,
+            EvaluatorAllWithPriority15,
+        ]
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_evaluators()
+
+        context.add_preprocess(BaseEvaluator.get_name("priority20"), enabled=False)
+        context.add_preprocess(BaseEvaluator.get_name("all_priority15"), priority=99)
+
+        groups, sorted_priorities = service.get_evaluators(context, BuiltinConcepts.EVALUATION)
+        assert groups == {99: [EvaluatorAllWithPriority15(99)]}
+        assert sorted_priorities == [99]
+
+        another_context = self.get_context(sheerka)
+        # the result is taken from the default cache, so the priorities are okay
+        # But the attributes of the evaluators are not reset
+        groups, sorted_priorities = service.get_evaluators(another_context, BuiltinConcepts.EVALUATION)
+        assert groups == {15: [EvaluatorAllWithPriority15(99)], 20: [EvaluatorOneWithPriority20(enabled=False)]}
+        assert sorted_priorities == [20, 15]
+
+        # let's revert
+        service.undo_preprocess()
+        groups, sorted_priorities = service.get_evaluators(another_context, BuiltinConcepts.EVALUATION)
+        assert groups == {15: [EvaluatorAllWithPriority15()], 20: [EvaluatorOneWithPriority20()]}
+        assert sorted_priorities == [20, 15]
+
     def test_that_return_values_is_unchanged_when_no_evaluator(self):
         sheerka = self.get_sheerka()
         sheerka.evaluators = []
@@ -299,7 +428,7 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
             EvaluatorOneWithPriority15,
             EvaluatorAllWithPriority20, ]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         entries = [self.tretval(sheerka, Concept("foo"))]
         Out.debug_out = []
@@ -324,7 +453,7 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
         sheerka = self.get_sheerka()
         sheerka.evaluators = [EvaluatorOneModifyFoo]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         entries = [self.tretval(sheerka, Concept("foo")), self.tretval(sheerka, Concept("baz"))]
         Out.debug_out = []
@@ -342,7 +471,7 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
         sheerka = self.get_sheerka()
         sheerka.evaluators = [EvaluatorAllReduceFooBar]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         entries = [self.tretval(sheerka, Concept("foo")), self.tretval(sheerka, Concept("bar"))]
         Out.debug_out = []
@@ -364,7 +493,7 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
         sheerka = self.get_sheerka()
         sheerka.evaluators = [EvaluatorOneModifyFoo, EvaluatorOneModifyBar]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         entries = [self.tretval(sheerka, Concept("foo")), self.tretval(sheerka, Concept("baz"))]
         Out.debug_out = []
@@ -391,7 +520,7 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
         sheerka = self.get_sheerka()
         sheerka.evaluators = [EvaluatorOneWithPriority10, EvaluatorOnePreEvaluation]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         entries = [self.tretval(sheerka, Concept("foo"))]
         Out.debug_out = []
@@ -406,7 +535,7 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
         sheerka = self.get_sheerka()
         sheerka.evaluators = [EvaluatorOneMultiSteps]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         entries = [self.tretval(sheerka, Concept("foo"))]
         Out.debug_out = []
@@ -426,8 +555,9 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
                               EvaluatorAllWithPriority15,
                               EvaluatorAllWithPriority10, ]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
-        context.preprocess_evaluators = [EvaluatorAllWithPriority10().short_name]  # it will be the only one to be evaluated
+        service.reset_registered_evaluators()
+        context.preprocess_evaluators = [
+            EvaluatorAllWithPriority10().short_name]  # it will be the only one to be evaluated
 
         entries = [self.tretval(sheerka, Concept("foo"))]
 
@@ -448,7 +578,7 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
                               EvaluatorOneWithPriority15,
                               EvaluatorOneWithPriority10, ]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         # invert the priorities
         context.add_preprocess(EvaluatorOneWithPriority20().name, priority=1)
@@ -468,17 +598,13 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
             '__EVALUATION [0] priority20 - eval - target=foo',
         ]
 
-        # grouped evaluator is in cache
-        service = sheerka.services[SheerkaExecute.NAME]
-        assert "__EVALUATION|evaluators.priority20|evaluators.priority15|evaluators.priority10" in service.grouped_evaluators_cache
-
     def test_evaluators_enabled_can_be_tweaked_by_the_context(self):
         sheerka, context = self.init_concepts()
         sheerka.evaluators = [EvaluatorOneWithPriority20,
                               EvaluatorOneWithPriority15,
                               EvaluatorOneWithPriority10, ]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         # invert the priorities
         context.add_preprocess(EvaluatorOneWithPriority20().name, enabled=False)
@@ -493,15 +619,11 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
             "__EVALUATION [0] priority10 - eval - target=foo",
         ]
 
-        # grouped evaluator is in cache
-        service = sheerka.services[SheerkaExecute.NAME]
-        assert "__EVALUATION|evaluators.priority10" in service.grouped_evaluators_cache
-
     def test_evaluators_can_be_pre_processed(self):
         sheerka = self.get_sheerka()
         sheerka.evaluators = [EvaluatorOneModifyFoo]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         entries = [self.tretval(sheerka, Concept("foo"))]
 
@@ -525,7 +647,7 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
         sheerka, context, foo, bar, baz = self.init_concepts("foo", "bar", "baz")
         sheerka.evaluators = [EvaluatorOneInitializationOnce]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         entries = [
             self.tretval(sheerka, foo),
@@ -548,7 +670,7 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
         sheerka, context, foo, bar, baz = self.init_concepts("foo", "bar", "baz")
         sheerka.evaluators = [EvaluatorOneInitializationMultiple]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         entries = [
             self.tretval(sheerka, foo),
@@ -578,7 +700,7 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
         sheerka = self.get_sheerka()
         sheerka.evaluators = [EvaluatorOneDoNotModifyExecutionFlow]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         entries = [self.tretval(sheerka, Concept("foo"))]
         Out.debug_out = []
@@ -600,7 +722,7 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
         sheerka = self.get_sheerka()
         sheerka.evaluators = [EvaluatorOneModifyFoo]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         entries = [self.tretval(sheerka, Concept("foo"))]
         Out.debug_out = []
@@ -619,7 +741,7 @@ class TestSheerkaExecuteEvaluators(TestUsingMemoryBasedSheerka):
         sheerka = self.get_sheerka()
         sheerka.evaluators = [EvaluatorAllSuppressEntries]
         service = sheerka.services[SheerkaExecute.NAME]
-        service.reset_evaluators()
+        service.reset_registered_evaluators()
 
         entries = [self.tretval(sheerka, Concept("foo")),
                    self.tretval(sheerka, Concept("bar")),

tests/core/test_sheerka_call_parsers.py

@@ -1,5 +1,5 @@
 from core.builtin_concepts import ReturnValueConcept, UserInputConcept, BuiltinConcepts, ParserResultConcept
-from core.sheerka.services.SheerkaExecute import ParserInput
+from core.sheerka.services.SheerkaExecute import ParserInput, SheerkaExecute
 from parsers.BaseParser import BaseParser
 
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
@@ -142,12 +142,74 @@ class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
         # Ask for a new one
         TestUsingMemoryBasedSheerka.singleton_instance = None
 
+    def test_i_can_get_parser_when_context_is_not_altered(self):
+        sheerka, context = self.init_concepts()
+        sheerka.parsers = {
+            "Enabled90False": Enabled90FalseParser,
+            "Enabled80False": Enabled80FalseParser,
+        }
+        service = SheerkaExecute(sheerka)
+        service.reset_registered_parsers()
+
+        groups, sorted_priorities = service.get_parsers(context)
+        assert groups == {80: [Enabled80FalseParser()], 90: [Enabled90FalseParser()]}
+        assert sorted_priorities == [90, 80]
+
+    def test_i_can_get_selected_parsers(self):
+        sheerka, context = self.init_concepts()
+        sheerka.parsers = {
+            "Enabled90False": Enabled90FalseParser,
+            "Enabled80False": Enabled80FalseParser,
+            "Enabled70False": Enabled70FalseParser,
+            "Enabled50True": Enabled50TrueParser,
+            "Disabled": Enabled50TrueParser,  # <= this one is disabled. It can't be used
+        }
+        service = SheerkaExecute(sheerka)
+        service.reset_registered_parsers()
+        parsers_names = ["Enabled50True", "Enabled70False", "Disabled"]
+        context.preprocess_parsers = parsers_names
+
+        groups, sorted_priorities = service.get_parsers(context)
+        assert groups == {50: [Enabled50TrueParser()], 70: [Enabled70FalseParser()]}
+        assert sorted_priorities == [70, 50]  # Disabled parser does not appear
+
+        key = "|".join(parsers_names)
+        assert key in service.grouped_parsers_cache
+        groups, sorted_priorities = service.grouped_parsers_cache[key]
+        assert groups == {50: [Enabled50TrueParser], 70: [Enabled70FalseParser]}
+        assert sorted_priorities == [70, 50]
+
+    def test_i_can_get_altered_parsers(self):
+        sheerka, context = self.init_concepts()
+        sheerka.parsers = {
+            "Enabled90False": Enabled90FalseParser,
+            "Enabled80False": Enabled80FalseParser,
+            "Enabled70False": Enabled70FalseParser,
+            "Enabled50True": Enabled50TrueParser,
+            "Disabled": Enabled50TrueParser,  # <= this one is disabled. It can't be used
+        }
+        service = SheerkaExecute(sheerka)
+        service.reset_registered_parsers()
+        parsers_names = ["Enabled90False", "Enabled50True", "Enabled70False", "Disabled"]
+        context.preprocess_parsers = parsers_names
+        context.add_preprocess(BaseParser.get_name("Enabled90False"), enabled=False)
+        context.add_preprocess(BaseParser.get_name("Enabled50True"), priority=80)
+
+        groups, sorted_priorities = service.get_parsers(context)
+        assert groups == {80: [Enabled50TrueParser()], 70: [Enabled70FalseParser()]}
+        assert sorted_priorities == [80, 70]  # Disabled parsers does not appear
+
+        key = "|".join(parsers_names)
+        assert key not in service.grouped_parsers_cache # not saved in cache
+
     def test_disabled_parsers_are_not_executed(self):
         sheerka = self.get_sheerka()
         sheerka.parsers = {
             "Enabled": Enabled10TrueParser,
             "Disabled": DisabledParser
         }
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_parsers()
 
         user_input = [get_ret_val("hello world")]
         BaseTestParser.debug_out = []
@@ -162,6 +224,8 @@ class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
             "Enabled80False": Enabled80FalseParser,
             "Enabled50True": Enabled50TrueParser,
         }
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_parsers()
 
         user_input = [get_ret_val("hello world")]
         BaseTestParser.debug_out = []
@@ -177,22 +241,25 @@ class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
             'name=Enabled50True, priority=50, status=True, source=Enabled80False:Enabled90False:hello world',
         ]
 
-    # def test_parsing_stop_at_the_first_success(self):
-    #     sheerka = self.get_sheerka()
-    #     sheerka.parsers = {
-    #         "Enabled80False": Enabled80FalseParser,
-    #         "Enabled50bisTrue": Enabled50bisTrueParser,
-    #         "Enabled10True": Enabled10TrueParser,
-    #     }
-    #
-    #     user_input = [get_ret_val("hello world")]
-    #     BaseTestParser.debug_out = []
-    #     sheerka.execute(self.get_context(sheerka), user_input, [BuiltinConcepts.PARSING])
-    #
-    #     assert BaseTestParser.debug_out == [
-    #         'name=Enabled80False, priority=80, status=False, source=hello world',
-    #         'name=Enabled50BisTrue, priority=50, status=True, source=hello world',
-    #     ]
+    def test_parsing_stop_at_the_first_success(self):
+        sheerka = self.get_sheerka()
+        sheerka.parsers = {
+            "Enabled80False": Enabled80FalseParser,
+            "Enabled50bisTrue": Enabled50bisTrueParser,
+            "Enabled10True": Enabled10TrueParser,
+        }
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_parsers()
+
+        user_input = [get_ret_val("hello world")]
+        BaseTestParser.debug_out = []
+        sheerka.execute(self.get_context(sheerka), user_input, [BuiltinConcepts.PARSING])
+
+        assert BaseTestParser.debug_out == [
+            'name=Enabled80False, priority=80, status=False, source=hello world',
+            'name=Enabled50BisTrue, priority=50, status=True, source=hello world',
+            'name=Enabled50BisTrue, priority=50, status=True, source=Enabled80False:hello world',
+        ]
 
     def test_parsing_stop_at_the_first_success_2(self):
         """
@@ -206,6 +273,8 @@ class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
             "Enabled50True": Enabled50TrueParser,
             "Enabled10True": Enabled10TrueParser,
         }
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_parsers()
 
         user_input = [get_ret_val("hello world")]
         BaseTestParser.debug_out = []
@@ -235,6 +304,8 @@ class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
             "Enabled50False": Enabled50FalseParser,
             "Enabled10True": Enabled10TrueParser,
         }
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_parsers()
 
         user_input = [get_ret_val("hello world")]
         BaseTestParser.debug_out = []
@@ -265,6 +336,8 @@ class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
             "Enabled80False": Enabled80FalseParser,
             "Enabled50True": Enabled50TrueParser,
         }
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_parsers()
 
         user_input = [get_ret_val("hello world")]
 
@@ -286,6 +359,8 @@ class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
             "NoneParser": NoneParser,
             "ListOfNone": ListOfNoneParser,
         }
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_parsers()
 
         user_input = [get_ret_val("hello world")]
 
@@ -310,6 +385,8 @@ class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
             "Enabled70False": Enabled70FalseParser,
             "Enabled50True": Enabled50TrueParser,
         }
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_parsers()
 
         user_input = [get_ret_val("hello world")]
         BaseTestParser.debug_out = []
@@ -329,6 +406,8 @@ class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
             "Enabled80MultipleFalse": Enabled80MultipleFalseParser,
             "Enabled50True": Enabled50TrueParser,
         }
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_parsers()
 
         user_input = [get_ret_val("hello world")]
         BaseTestParser.debug_out = []
@@ -356,6 +435,8 @@ class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
             "Enabled80MultipleTrue": Enabled80MultipleTrueParser,
             "Enabled50True": Enabled50TrueParser,
         }
+        service = sheerka.services[SheerkaExecute.NAME]
+        service.reset_registered_parsers()
 
         user_input = [get_ret_val("hello world")]
         BaseTestParser.debug_out = []

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)

tests/non_reg/test_sheerka_non_reg.py

@@ -43,11 +43,7 @@ class TestSheerkaNonRegMemory(TestUsingMemoryBasedSheerka):
         assert evaluated == simplec("one", 1)
 
     def test_i_can_recognize_concept_with_concept_body(self):
-        sheerka = self.get_sheerka()
-        concept_one = Concept(name="one")
-        concept_un = Concept(name="un", body="one")
-        sheerka.test_only_add_in_cache(concept_one)
-        sheerka.test_only_add_in_cache(concept_un)
+        sheerka, context, concept_one, concept_un = self.init_concepts("one", Concept(name="un", body="one"))
 
         res = sheerka.evaluate_user_input("un")
         return_value = res[0].value
@@ -202,9 +198,10 @@ as:
         assert evaluated.get_value("a") == concept_foo
 
     def test_i_can_recognize_concept_with_variable_and_python_as_body(self):
-        sheerka = self.get_sheerka()
-        hello_a = sheerka.test_only_add_in_cache(Concept(name="hello a", body="'hello ' + a").def_var("a"))
-        sheerka.test_only_add_in_cache(Concept(name="foo", body="'foo'"))
+        sheerka, context, hello_a, foo = self.init_concepts(
+            Concept(name="hello a", body="'hello ' + a").def_var("a"),
+            Concept(name="foo", body="'foo'")
+        )
 
         res = sheerka.evaluate_user_input("hello foo")
         assert len(res) == 1
@@ -1199,6 +1196,18 @@ as:
         assert res[0].status
         assert sheerka.isinstance(res[0].body, BuiltinConcepts.TO_MULTI)
 
+    def test_i_can_evaluate_pseudo_recursive_definition(self):
+        init = [
+            "def concept a + b as a + b",
+        ]
+        sheerka = self.init_scenario(init)
+
+        res = sheerka.evaluate_user_input("eval 1 + 1")
+
+        assert len(res) == 1
+        assert res[0].status
+        assert res[0].body == 2
+
 
 class TestSheerkaNonRegFile(TestUsingFileBasedSheerka):
     def test_i_can_def_several_concepts(self):