Fixed #72 : Exception when get_results(id=10)

Fixed #74 : Keyword parameters are no longer recognized when a concept that redefines equality is created
Fixed #118 : RecursionError: maximum recursion depth exceeded
Fixed #119 : PreventCircularReferenceEvaluator
Fixed #121 : Plural are not updated when new elements are added
Fixed #123 : BaseCache : Values in cache can be evicted before being committed
Fixed #105 : TOO_MANY_ERROR is not the relevant error when results are filtered

tests/evaluators/EvaluatorTestsUtils.py

@@ -135,6 +135,11 @@ def cnode_ret_val(concept, source=None, parser=sya):
     return pr_ret_val([cnode], parser=parser, source=source)
 
 
+def concept_ret_val(concept, source=None, parser=exact):
+    source = source or concept.name
+    return pr_ret_val(concept, parser=parser, 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_MultipleErrorsEvaluator.py

@@ -1,11 +1,10 @@
 import pytest
 
-from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts
+from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept
 from core.concept import Concept
 from evaluators.BaseEvaluator import BaseEvaluator
 from evaluators.MultipleErrorsEvaluator import MultipleErrorsEvaluator
 from parsers.BaseParser import BaseParser
-
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
 
 
@@ -13,8 +12,8 @@ def r(value, status=True):
     return ReturnValueConcept(value, status, value)
 
 
-def eval_false(name):
-    return ReturnValueConcept(BaseEvaluator.PREFIX + name, False, "value")
+def eval_false(name, value="value"):
+    return ReturnValueConcept(BaseEvaluator.PREFIX + name, False, value)
 
 
 def eval_true(name):
@@ -32,7 +31,7 @@ def parser_true(name):
 reduce_requested = ReturnValueConcept(
     "some_name",
     True,
-    Concept(name=BuiltinConcepts.REDUCE_REQUESTED,  key=BuiltinConcepts.REDUCE_REQUESTED))
+    Concept(name=BuiltinConcepts.REDUCE_REQUESTED, key=BuiltinConcepts.REDUCE_REQUESTED))
 
 
 class TestMultipleErrorsEvaluator(TestUsingMemoryBasedSheerka):
@@ -96,3 +95,21 @@ class TestMultipleErrorsEvaluator(TestUsingMemoryBasedSheerka):
 
         assert a_successful_concept not in res.parents
         assert a_concept_in_error not in res.parents
+
+    def test_filtered_results_are_not_considered_as_error(self):
+        sheerka, context = self.init_concepts()
+
+        filtered = sheerka.new(BuiltinConcepts.FILTERED)
+        filtered_ret_val = eval_false("Filter", filtered)
+        false_1 = eval_false("one")
+        false_2 = eval_false("two")
+
+        evaluator = MultipleErrorsEvaluator()
+        assert not evaluator.matches(context, [filtered_ret_val, false_1, reduce_requested])
+
+        evaluator.reset()
+        return_values = [filtered_ret_val, false_1, false_2, reduce_requested]
+        assert evaluator.matches(context, return_values)
+        res = evaluator.eval(context, return_values)
+        assert not res.status
+        assert res.parents == return_values

tests/evaluators/test_OneErrorEvaluator.py

@@ -1,9 +1,9 @@
 import pytest
 
-from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts
+from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept
 from core.concept import Concept
+from evaluators.BaseEvaluator import BaseEvaluator
 from evaluators.OneErrorEvaluator import OneErrorEvaluator
-
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
 
 
@@ -11,6 +11,10 @@ def r(value, status=True):
     return ReturnValueConcept(value, status, value)
 
 
+def eval_false(name, value="value"):
+    return ReturnValueConcept(BaseEvaluator.PREFIX + name, False, value)
+
+
 reduce_requested = ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.REDUCE_REQUESTED))
 
 
@@ -72,3 +76,34 @@ class TestOneErrorEvaluator(TestUsingMemoryBasedSheerka):
 
         assert a_successful_concept not in res.parents
         assert a_concept_in_error not in res.parents
+
+    def test_i_can_manage_filtered_return_values(self):
+        sheerka, context = self.init_concepts()
+
+        filtered = sheerka.new(BuiltinConcepts.FILTERED)
+        filtered_ret_val = eval_false("Filter", filtered)
+        false_1 = eval_false("one")
+
+        evaluator = OneErrorEvaluator()
+        return_values = [filtered_ret_val, false_1, reduce_requested]
+        assert evaluator.matches(context, return_values)
+        res = evaluator.eval(context, return_values)
+        assert not res.status
+        assert res.body == false_1.body
+        assert res.parents == return_values
+
+        evaluator.reset()
+        return_values = [filtered_ret_val, reduce_requested]
+        assert evaluator.matches(context, return_values)
+        res = evaluator.eval(context, return_values)
+        assert not res.status
+        assert res.body == filtered
+        assert res.parents == return_values
+
+        evaluator.reset()
+        return_values = [false_1, reduce_requested]
+        assert evaluator.matches(context, return_values)
+        res = evaluator.eval(context, return_values)
+        assert not res.status
+        assert res.body == false_1.body
+        assert res.parents == return_values

tests/evaluators/test_PreventCircularReferenceEvaluator.py

@@ -0,0 +1,89 @@
+from core.builtin_concepts_ids import BuiltinConcepts
+from core.concept import Concept, DEFINITION_TYPE_DEF
+from core.sheerka.services.sheerka_service import ChickenAndEggException
+from evaluators.PreventCircularReferenceEvaluator import PreventCircularReferenceEvaluator
+from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
+from tests.evaluators.EvaluatorTestsUtils import cnode_ret_val, concept_ret_val, python_ret_val
+
+
+class TestPreventCircularReferenceEvaluator(TestUsingMemoryBasedSheerka):
+    def test_i_can_match(self):
+        sheerka, context, foo = self.init_concepts("foo")
+
+        level1 = context.push(BuiltinConcepts.TESTING, None)
+        level2 = level1.push(BuiltinConcepts.EVALUATING_CONCEPT, foo)
+        level3 = level2.push(BuiltinConcepts.TESTING, None)
+        level4 = level3.push(BuiltinConcepts.TESTING, None)
+
+        assert not PreventCircularReferenceEvaluator().matches(context, [])
+        assert not PreventCircularReferenceEvaluator().matches(level1, [])
+        assert not PreventCircularReferenceEvaluator().matches(level2, [])  # only detect sub context
+        assert PreventCircularReferenceEvaluator().matches(level3, [])
+        assert PreventCircularReferenceEvaluator().matches(level4, [])
+
+    def test_i_can_eval(self):
+        sheerka, context, foo, bar = self.init_concepts("foo", "bar")
+
+        level1 = context.push(BuiltinConcepts.EVALUATING_CONCEPT, foo)
+        level2 = level1.push(BuiltinConcepts.TESTING, None)
+
+        python = python_ret_val("1 + 1")
+        cnode_foo = cnode_ret_val(foo)
+        exact_foo = concept_ret_val(foo)
+        exact_bar = concept_ret_val(bar)
+
+        # no circular
+        return_values = [python, exact_bar]
+        evaluator = PreventCircularReferenceEvaluator()
+        assert evaluator.matches(level2, return_values)
+        assert evaluator.eval(level2, return_values) is None
+
+        # circular with exact concept parser
+        return_values = [python, exact_foo]
+        evaluator = PreventCircularReferenceEvaluator()
+        assert evaluator.matches(level2, return_values)
+        ret = evaluator.eval(level2, return_values)
+        assert not ret.status
+        assert sheerka.isinstance(ret.body, BuiltinConcepts.FILTERED)
+        assert ret.body.filtered == [exact_foo]
+        assert isinstance(ret.body.reason, ChickenAndEggException)
+        assert ret.parents == [exact_foo]
+
+        # circular with node concept (can by Sya or Sequence. It does not matter)
+        return_values = [python, cnode_foo]
+        evaluator = PreventCircularReferenceEvaluator()
+        assert evaluator.matches(level2, return_values)
+        ret = evaluator.eval(level2, return_values)
+        assert not ret.status
+        assert sheerka.isinstance(ret.body, BuiltinConcepts.FILTERED)
+        assert ret.body.filtered == [cnode_foo]
+        assert isinstance(ret.body.reason, ChickenAndEggException)
+        assert ret.parents == [cnode_foo]
+
+        # circular when multiple concepts
+        return_values = [python, exact_foo, cnode_foo]
+        evaluator = PreventCircularReferenceEvaluator()
+        assert evaluator.matches(level2, return_values)
+        ret = evaluator.eval(level2, return_values)
+        assert not ret.status
+        assert sheerka.isinstance(ret.body, BuiltinConcepts.FILTERED)
+        assert ret.body.filtered == [exact_foo, cnode_foo]
+        assert isinstance(ret.body.reason, ChickenAndEggException)
+        assert ret.parents == [exact_foo, cnode_foo]
+
+    def test_i_cannot_eval_when_the_name_of_the_concept_is_also_a_parameter_of_the_concept(self):
+        sheerka, context, q = self.init_concepts(
+            Concept("q", definition="q ?", definition_type=DEFINITION_TYPE_DEF).def_var("q")
+        )
+
+        level1 = context.push(BuiltinConcepts.EVALUATING_CONCEPT, q)
+        level2 = level1.push(BuiltinConcepts.TESTING, None)
+
+        python = python_ret_val("1 + 1")
+        cnode_q = cnode_ret_val(q)
+        exact_q = concept_ret_val(q)
+
+        return_values = [python, cnode_q, exact_q]
+        evaluator = PreventCircularReferenceEvaluator()
+        assert evaluator.matches(level2, return_values)
+        assert evaluator.eval(level2, return_values) is None