Fixed #43 : BnfNodeParser: I can recognize when multiple level of ISA

Fixed #44 : BnfNodeParser: I must simplify results when multiple levels of ISA
Fixed #45 : Dynamic variables cannot be parsed at restart
Fixed #46 : Concepts variables values are transformed into list by default
Fixed #47 : SheerkaAdmin. Add min, max, mean time when restoring files

tests/TestUsingFileBasedSheerka.py

@@ -26,7 +26,7 @@ class TestUsingFileBasedSheerka(BaseTest):
             TestUsingFileBasedSheerka.ontologies_created.clear()
 
     @staticmethod
-    def new_sheerka_instance(cache_only):
+    def new_sheerka_instance(cache_only=False):
         sheerka = Sheerka(cache_only=cache_only)
         sheerka.initialize(SHEERKA_TEST_FOLDER,
                            save_execution_context=False,

tests/core/test_SheerkaConceptManager.py

@@ -798,6 +798,34 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
 
         assert sheerka.get_attr(foo, prop) == bar
 
+    def test_i_setting_twice_the_same_property_creates_a_list(self):
+        sheerka, context = self.init_concepts()
+        foo = Concept("foo")
+        prop = Concept("property")
+        bar = Concept("bar")
+        baz = Concept("baz")
+        qux = Concept("qux")
+
+        res = sheerka.set_attr(foo, prop, bar)
+        assert res.status
+        assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
+        assert sheerka.get_attr(foo, prop) == bar
+
+        res = sheerka.set_attr(foo, prop, bar)  # again, same value as no effect
+        assert res.status
+        assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
+        assert sheerka.get_attr(foo, prop) == bar
+
+        res = sheerka.set_attr(foo, prop, baz)
+        assert res.status
+        assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
+        assert sheerka.get_attr(foo, prop) == [bar, baz]
+
+        res = sheerka.set_attr(foo, prop, qux)
+        assert res.status
+        assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
+        assert sheerka.get_attr(foo, prop) == [bar, baz, qux]
+
     def test_i_cannot_remove_a_concept_which_has_reference(self):
         sheerka, context, one, twenty_one = self.init_test().with_concepts(
             Concept("one"),
@@ -1067,6 +1095,27 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
             'hundred': ['1005', '1007'],
         }
 
+    def test_i_can_resolve_when_concepts_have_multiple_levels_of_sets(self):
+        sheerka, context, adjective, color, red, qualified_table = self.init_concepts(
+            "adjective",
+            "color",
+            "red",
+            Concept("qualified table", definition="adjective 'table'"),
+        )
+
+        sheerka.set_isa(context, color, adjective)
+        sheerka.set_isa(context, red, color)
+
+        by_first_token = compute_concepts_by_first_token(context, [adjective, color, red, qualified_table]).body
+        resolved_ret_val = resolve_concepts_by_first_keyword(context, by_first_token)
+
+        assert resolved_ret_val.status
+        assert resolved_ret_val.body == {
+            'adjective': ['1001'],
+            'color': ['1002'],
+            'red': ['1003', '1004'],
+        }
+
     def test_concepts_are_defined_once(self):
         sheerka = self.get_sheerka()
         context = self.get_context(sheerka)

tests/core/test_sheerka.py

@@ -120,6 +120,14 @@ class TestSheerkaUsingMemoryBasedSheerka(TestUsingMemoryBasedSheerka):
         assert new.get_value("a") == 10
         assert new.get_value("b") == "value"
 
+    def test_i_can_instantiate_concepts_when_variables_are_defined_in_constructor(self):
+        sheerka, context, foo = self.init_test().with_concepts(
+            Concept(name="foo", variables=[("x", "default value for x"), ("y", None)]),
+            create_new=True).unpack()
+
+        new = sheerka.new(foo.key)
+        assert new.values() == {"x": NotInit, "y": NotInit}  # default values are not used ?
+
     def test_i_can_instantiate_multiple_when_same_key(self):
         sheerka, context, *concepts = self.init_test().with_concepts(
             Concept("foo", body="foo1"),

tests/core/test_utils.py

@@ -386,8 +386,10 @@ def test_i_can_deep_copy_a_concept():
                        desc="concept2_desc",
                        id="concept2_ids",
                        props={"prop_name": concept1},
-                       variables=[("var1", "default_value1"), ("var2", "default_value2")],
+                       variables=[("var21", "default_value21"), ("var22", "default_value22")],
                        bound_body="var1")
+    concept2.set_value("var21", "default_value21")
+    concept2.set_value("var22", "default_value22")
 
     concept = Concept(name="my_name",
                       is_builtin=True,

tests/non_reg/test_sheerka_non_reg.py

@@ -7,8 +7,6 @@ from core.sheerka.services.SheerkaConceptManager import SheerkaConceptManager
 from evaluators.MutipleSameSuccessEvaluator import MultipleSameSuccessEvaluator
 from evaluators.OneSuccessEvaluator import OneSuccessEvaluator
 from evaluators.PythonEvaluator import PythonEvalError
-from parsers.BnfNodeParser import Sequence, StrMatch, OrderedChoice, Optional, ConceptExpression
-from tests.TestUsingFileBasedSheerka import TestUsingFileBasedSheerka
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
 from tests.parsers.parsers_utils import CMV, CC, compare_with_test_object, CB
 
@@ -1299,7 +1297,7 @@ as:
 
         assert sheerka.objvalue(res[0].body.get_value("qty")) == 2
 
-    def test_i_can_implement_implement_the_concept_and(self):
+    def test_i_can_implement_the_concept_and(self):
         init = [
             "def concept x and y as x and y",
             "set_is_lesser(__PRECEDENCE, c:x and y:, 'Sya')",
@@ -1310,4 +1308,3 @@ as:
 
         assert len(res) == 1
         assert res[0].status
-

tests/non_reg/test_sheerka_non_reg_file_based.py

@@ -1,4 +1,5 @@
 from core.builtin_concepts_ids import BuiltinConcepts
+from core.concept import get_concept_attrs, Concept, ALL_ATTRIBUTES
 from core.sheerka.services.SheerkaConceptManager import SheerkaConceptManager
 from parsers.BnfNodeParser import OrderedChoice, StrMatch, Sequence, ConceptExpression, Optional
 from tests.TestUsingFileBasedSheerka import TestUsingFileBasedSheerka
@@ -86,7 +87,7 @@ class TestSheerkaNonRegFile(TestUsingFileBasedSheerka):
             "set_isa(thirties, number)",
         ])
 
-        sheerka = self.get_sheerka()  # another instance
+        sheerka = self.new_sheerka_instance()
 
         assert sheerka.evaluate_user_input("eval twenty one")[0].body == 21
         assert sheerka.evaluate_user_input("eval thirty one")[0].body == 31
@@ -95,10 +96,29 @@ class TestSheerkaNonRegFile(TestUsingFileBasedSheerka):
         sheerka = self.get_sheerka()
         sheerka.evaluate_user_input("push_ontology('test')")
 
-        sheerka = self.new_sheerka_instance(False)
+        sheerka = self.new_sheerka_instance()
 
         res = sheerka.evaluate_user_input("pop_ontology()")
 
         assert len(res) == 1
         assert res[0].status
         assert sheerka.isinstance(res[0].body, BuiltinConcepts.ONTOLOGY_REMOVED)
+
+    def test_i_can_read_concept_with_dynamic_variables_at_restart(self):
+        sheerka = self.init_scenario([
+            "def concept foo",
+            "def concept prop_name",
+            "def concept prop_value",
+            "eval foo",
+            "set_attr(foo, prop_name, prop_value)",
+        ])
+
+        ALL_ATTRIBUTES.clear()
+
+        res = sheerka.evaluate_user_input("in_memory()")
+        res = sheerka.evaluate_user_input("memory(foo)")
+        assert len(res) == 1
+        assert res[0].status
+
+        assert get_concept_attrs(Concept("foo")) == []
+        assert get_concept_attrs(res[0].body) == ['c:prop_name|1002:']

tests/non_reg/test_sheerka_non_reg_out.py

@@ -32,6 +32,7 @@ name      : foo
 key       : foo
 definition: None
 type      : None
+hash      : 16f7fbb8bc509b8c652edaf3d0c0457d15a37f0a862fbe03fa357b0c77249c46
 body      : 1
 where     : None
 pre       : None
@@ -44,6 +45,7 @@ name      : foo
 key       : foo
 definition: None
 type      : None
+hash      : 7036cd5ffa9294d2e1dc9bf9c9bbe2783ace5cf7f423bfce9b28c8d33c0d1d0c
 body      : 2
 where     : None
 pre       : None

tests/parsers/test_BnfNodeParser.py

@@ -1889,6 +1889,44 @@ class TestBnfNodeParser(TestUsingMemoryBasedSheerka):
         assert isinstance(resolved.nodes[1], VariableExpression)
         assert resolved.nodes[0].nodes == []
 
+    def test_i_can_simplify_unordered_choices_that_refer_to_the_same_isa(self):
+        my_map = {
+            "light_red": Concept("light red"),
+            "dark_red": Concept("dark red"),
+            "red colors": Concept("red colors"),
+            "color": Concept("color"),
+            "adjective": Concept("adjective"),
+            "qualified table": Concept("qualified table", definition="adjective 'table'"),
+        }
+
+        sheerka, context, parser = self.init_parser(my_map, init_from_sheerka=True, create_new=True)
+        sheerka.set_isa(context, my_map["light_red"], my_map["adjective"])
+        sheerka.set_isa(context, my_map["dark_red"], my_map["adjective"])
+        sheerka.set_isa(context, my_map["light_red"], my_map["color"])
+        sheerka.set_isa(context, my_map["dark_red"], my_map["color"])
+        sheerka.set_isa(context, my_map["light_red"], my_map["red colors"])
+        sheerka.set_isa(context, my_map["dark_red"], my_map["red colors"])
+        sheerka.set_isa(context, my_map["color"], my_map["adjective"])
+        sheerka.set_isa(context, my_map["red colors"], my_map["color"])
+        sheerka.set_isa(context, my_map["red colors"], my_map["adjective"])
+
+        text = "light red table"
+
+        expected = CNC("qualified table",
+                       source=text,
+                       body=DoNotResolve(text),
+                       adjective=CC("adjective",
+                                    source="light red",
+                                    body=CC("light_red", source="light red"),
+                                    light_red=CC("light_red", source="light red")))
+        expected_array = compute_expected_array(my_map, text, [expected])
+
+        res = parser.parse(context, ParserInput(text))
+        # there should be only one result !!
+        assert not isinstance(res, list)
+        assert res.status
+        compare_with_test_object(res.value.value, expected_array)
+
     # @pytest.mark.parametrize("parser_input, expected", [
     #     ("one", [
     #         (True, [CNC("bnf_one", source="one", one="one", body="one")]),