Added set of set handling (thru concept ISA)

tests/BaseTest.py

@@ -3,11 +3,12 @@ import ast
 from core.builtin_concepts import ReturnValueConcept, ParserResultConcept
 from core.concept import Concept
 from core.sheerka.ExecutionContext import ExecutionContext
+from parsers.BnfParser import BnfParser
 from sdp.sheerkaDataProvider import Event
 
 
 class BaseTest:
-    def get_sheerka(self):
+    def get_sheerka(self, **kwargs):
         pass
 
     def get_context(self, sheerka=None):
@@ -32,6 +33,30 @@ class BaseTest:
             dump = dump.replace(to_remove, "")
         return dump
 
+    def init_concepts(self, *concepts, **kwargs):
+        sheerka = self.get_sheerka(**kwargs)
+        context = self.get_context(sheerka)
+
+        result = []
+        for c in concepts:
+            if isinstance(c, str):
+                c = Concept(c)
+            c.init_key()
+            sheerka.set_id_if_needed(c, False)
+
+            # manage concepts with bnf definitions
+            if c.metadata.definition:
+                bnf_parser = BnfParser()
+                res = bnf_parser.parse(context, c.metadata.definition)
+                if res.status:
+                    c.bnf = res.value.value
+                sheerka.create_new_concept(context, c)
+
+            sheerka.add_in_cache(c)
+            result.append(c)
+
+        return sheerka, context, *result
+
     @staticmethod
     def retval(obj, who="who", status=True):
         """ret_val"""

tests/TestUsingFileBasedSheerka.py

@@ -26,7 +26,9 @@ class TestUsingFileBasedSheerka(BaseTest):
 
         os.chdir(current_pwd)
 
-    def get_sheerka(self, use_dict=True, skip_builtins_in_db=True):
+    def get_sheerka(self,  **kwargs):
+        use_dict = kwargs.get("use_dict", True)
+        skip_builtins_in_db = kwargs.get("skip_builtins_in_db", True)
         root = "mem://" if use_dict else self.root_folder
         sheerka = Sheerka(skip_builtins_in_db=skip_builtins_in_db)
         sheerka.initialize(root)

tests/TestUsingMemoryBasedSheerka.py

@@ -4,7 +4,8 @@ from tests.BaseTest import BaseTest
 
 class TestUsingMemoryBasedSheerka(BaseTest):
 
-    def get_sheerka(self, skip_builtins_in_db=True):
+    def get_sheerka(self, **kwargs):
+        skip_builtins_in_db = kwargs.get("skip_builtins_in_db", True)
         sheerka = Sheerka(skip_builtins_in_db=skip_builtins_in_db)
         sheerka.initialize("mem://")
         return sheerka

tests/core/test_SheerkaEvaluateConcept.py

@@ -457,3 +457,4 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
         evaluated = sheerka.evaluate_concept(self.get_context(sheerka), one)
         assert evaluated.key == one.key
         assert evaluated.body == 1
+

tests/core/test_SheerkaSetsManager.py

@@ -6,41 +6,39 @@ from tests.TestUsingFileBasedSheerka import TestUsingFileBasedSheerka
 
 class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
 
-    def init(self, use_dict, *concepts):
-        sheerka = self.get_sheerka(use_dict, True)
-        for c in concepts:
-            sheerka.set_id_if_needed(c, False)
-            sheerka.add_in_cache(c)
-
-        context = self.get_context(sheerka)
-        return sheerka, context
+    # def init(self, use_dict, *concepts):
+    #     sheerka = self.get_sheerka(use_dict, True)
+    #     for c in concepts:
+    #         sheerka.set_id_if_needed(c, False)
+    #         sheerka.add_in_cache(c)
+    #
+    #     context = self.get_context(sheerka)
+    #     return sheerka, context
 
     def test_i_can_add_concept_to_set(self):
-        foo = Concept("foo")
-        all_foos = Concept("all_foos")
-        sheerka, context = self.init(False, foo, all_foos)
+        sheerka, context, foo, all_foos = self.init_concepts(Concept("foo"), Concept("all_foo"), use_dict=False)
 
         res = sheerka.add_concept_to_set(context, foo, all_foos)
 
         assert res.status
         assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
 
-        all_entries = self.get_sheerka(False, True).sdp.get("All_" + all_foos.id, None, False)
+        all_entries = self.get_sheerka(use_dict=False).sdp.get("All_" + all_foos.id, None, False)
         assert len(all_entries) == 1
         assert foo.id in all_entries
 
     def test_i_can_add_several_concepts_to_set(self):
-        foo1 = Concept("foo1")
-        foo2 = Concept("foo2")
-        all_foos = Concept("all_foos")
-        sheerka, context = self.init(False, foo1, foo2, all_foos)
+        sheerka, context, foo1, foo2, all_foos = self.init_concepts(
+            Concept("foo1"),
+            Concept("foo2"),
+            Concept("all_foo"), use_dict=False)
 
         res = sheerka.sets_handler.add_concepts_to_set(context, (foo1, foo2), all_foos)
 
         assert res.status
         assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
 
-        all_entries = self.get_sheerka(False, False).sdp.get("All_" + all_foos.id, None, False)
+        all_entries = self.get_sheerka(use_dict=False).sdp.get("All_" + all_foos.id, None, False)
         assert len(all_entries) == 2
         assert foo1.id in all_entries
         assert foo2.id in all_entries
@@ -57,7 +55,7 @@ class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
         assert res.status
         assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
 
-        all_entries = self.get_sheerka(False, False).sdp.get("All_" + all_foos.id, None, False)
+        all_entries = self.get_sheerka(use_dict=False).sdp.get("All_" + all_foos.id, None, False)
         assert len(all_entries) == 4
         assert foo1.id in all_entries
         assert foo2.id in all_entries
@@ -65,9 +63,7 @@ class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
         assert foo4.id in all_entries
 
     def test_i_cannot_add_the_same_concept_twice_in_a_set(self):
-        foo = Concept("foo")
-        all_foos = Concept("all_foos")
-        sheerka, context = self.init(True, foo, all_foos)
+        sheerka, context, foo, all_foos = self.init_concepts(Concept("foo"), Concept("all_foos"))
 
         sheerka.add_concept_to_set(context, foo, all_foos)
         res = sheerka.add_concept_to_set(context, foo, all_foos)
@@ -80,40 +76,179 @@ class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
         assert foo.id in all_entries
 
     def test_i_get_elements_from_a_set(self):
-        one = Concept("one")
-        two = Concept("two")
-        three = Concept("three")
-        number = Concept("number")
-        sheerka, context = self.init(True, one, two, three, number)
+        sheerka, context, one, two, three, number = self.init_concepts(
+            Concept("one"), Concept("two"), Concept("three"), Concept("number"))
 
         for c in [one, two, three]:
             sheerka.add_concept_to_set(context, c, number)
 
-        elements = sheerka.get_set_elements(number)
+        elements = sheerka.get_set_elements(context, number)
 
         assert set(elements) == {one, two, three}
 
     def test_i_cannot_get_elements_if_not_a_set(self):
-        one = Concept("one")
-        sheerka, context = self.init(True, one)
+        sheerka, context, one = self.init_concepts(Concept("one"))
 
-        error = sheerka.get_set_elements(one)
+        error = sheerka.get_set_elements(context, one)
 
         assert sheerka.isinstance(error, BuiltinConcepts.NOT_A_SET)
         assert error.body == one
 
     def test_isa_and_isa_group(self):
-        group = Concept("group")
-        foo = Concept("foo")
-        sheerka, context = self.init(True, group, foo)
+        sheerka, context, group, foo = self.init_concepts(Concept("group"), Concept("foo"))
 
-        assert not sheerka.isaset(group)
-        assert not sheerka.isa(foo, group)
+        assert not sheerka.isaset(context, group)
+        assert not sheerka.isinset(foo, group)
 
         context = self.get_context(sheerka)
         sheerka.add_concept_to_set(context, foo, group)
-        assert sheerka.isaset(group)
-        assert sheerka.isa(foo, group)
+        assert sheerka.isaset(context, group)
+        assert sheerka.isinset(foo, group)
 
-    def test_i_can_a_multiples_concepts(self):
-        pass
+    def test_i_can_define_a_group_from_another_group(self):
+        sheerka, context, foo, bar, group1, group2 = self.init_concepts(
+            Concept("foo"), Concept("bar"), Concept("group1"), Concept("group2", body="group1"))
+
+        sheerka.sets_handler.add_concepts_to_set(context, [foo, bar], group1)
+
+        assert sheerka.isaset(context, group2)
+        assert sheerka.get_set_elements(context, group2) == [foo, bar]
+
+    def test_i_can_define_subset_of_another_group(self):
+        sheerka, context, one, two, three, four, five, number, sub_number = self.init_concepts(
+            Concept("one", body="1"),
+            Concept("two", body="2"),
+            Concept("three", body="3"),
+            Concept("four", body="4"),
+            Concept("five", body="5"),
+            Concept("number"),
+            Concept("sub_number", body="number", where="number < 4")
+        )
+        sheerka.sets_handler.add_concepts_to_set(context, [one, two, three, four, five], number)
+
+        assert sheerka.isaset(context, sub_number)
+        assert sheerka.get_set_elements(context, sub_number) == [one, two, three]
+
+    def test_i_can_define_subset_of_another_set_when_some_concept_dont_have_a_defined_body(self):
+        """
+        Example
+        def concept unit from number where number <10
+        It implies that all elements in number have a (numeric) body
+        What if its not the case ?
+        :return:
+        """
+
+        sheerka, context, one, two, three, four, five, number, sub_number = self.init_concepts(
+            Concept("one", body="1"),
+            Concept("two"),
+            Concept("three", body="3"),
+            Concept("four"),
+            Concept("five", body="5"),
+            Concept("number"),
+            Concept("sub_number", body="number", where="number < 4")
+        )
+        sheerka.sets_handler.add_concepts_to_set(context, [one, two, three, four, five], number)
+
+        assert sheerka.isaset(context, sub_number)
+        assert sheerka.get_set_elements(context, sub_number) == [one, three]
+
+    def test_i_can_define_subset_of_another_set_when_some_concept_are_bnf(self):
+        """
+        Other case:
+        twenties isa number, but its body is a source code, not a constant numeric number
+        is it included ?
+        :return:
+        """
+
+        sheerka, context, one, two, twenty, twenties, number, sub_number = self.init_concepts(
+            Concept("one", body="1"),
+            Concept("two", body="2"),
+            Concept("twenty", body="20"),
+            Concept("twenties", definition="twenty (one|two)=unit", body="twenty + unit"),
+            Concept("number"),
+            Concept("sub_number", body="number", where="number >= 20")
+        )
+
+        sheerka.sets_handler.add_concepts_to_set(context, [one, two, twenty, twenties], number)
+
+        assert sheerka.isaset(context, sub_number)
+        assert sheerka.get_set_elements(context, sub_number) == [twenty]  # what is expected ?
+
+    def test_bnf_elements_can_be_part_of_a_set(self):
+        """
+        The purpose of this test is
+        def concept twenties from bnf ...
+        twenties isa number
+
+        assert twenty two isa number
+        We want that all elements of the twenties are number
+        :return:
+        """
+
+        sheerka, context, one, two, twenty, twenties, number = self.init_concepts(
+            Concept("one", body="1"),
+            Concept("two", body="2"),
+            Concept("twenty", body="20"),
+            Concept("twenties", definition="twenty (one|two)=unit", body="twenty + unit").def_prop("unit"),
+            Concept("number"),
+        )
+
+        sheerka.sets_handler.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)
+
+    def test_i_can_set_isa(self):
+        sheerka, context, foo, all_foos = self.init_concepts(Concept("foo"), Concept("all_foo"), use_dict=False)
+        sheerka.create_new_concept(context, foo)
+
+        assert BuiltinConcepts.ISA not in foo.props
+
+        sheerka.set_isa(context, foo, all_foos)
+
+        assert foo.get_prop(BuiltinConcepts.ISA) == [all_foos]
+        assert sheerka.isa(foo, all_foos)
+        assert sheerka.isinset(foo, all_foos)
+        assert sheerka.isaset(context, all_foos)
+
+    def test_a_concept_can_be_in_multiple_sets(self):
+        sheerka, context, foo, all_foos, all_bars = self.init_concepts(
+            Concept("foo"),
+            Concept("all_foo"),
+            Concept("all_bar"),
+            use_dict=False)
+        sheerka.create_new_concept(context, foo)
+
+        sheerka.set_isa(context, foo, all_foos)
+        sheerka.set_isa(context, foo, all_bars)
+
+        assert foo.get_prop(BuiltinConcepts.ISA) == [all_foos, all_bars]
+        assert sheerka.isa(foo, all_foos)
+        assert sheerka.isa(foo, all_bars)
+        assert sheerka.isinset(foo, all_foos)
+        assert sheerka.isinset(foo, all_bars)
+        assert sheerka.isaset(context, all_foos)
+        assert sheerka.isaset(context, all_bars)
+
+    def test_i_can_manage_isa_transitivity(self):
+        """
+        if foo isa bar and bar isa baz, then foo isa baz
+        :return:
+        """
+
+        sheerka, context, foo, bar, baz = self.init_concepts(
+            Concept("foo"),
+            Concept("bar"),
+            Concept("baz"),
+        )
+        sheerka.create_new_concept(context, foo)
+        sheerka.create_new_concept(context, bar)
+        sheerka.create_new_concept(context, baz)
+
+        sheerka.set_isa(context, foo, bar)
+        sheerka.set_isa(context, bar, baz)
+
+        assert sheerka.isa(foo, bar)
+        assert sheerka.isa(bar, baz)
+        assert sheerka.isa(foo, baz)

tests/core/test_ast.py

@@ -42,7 +42,7 @@ def my_function(a,b):
     assert tree_as_concept.node_type == "Module"
     assert sheerka.isinstance(tree_as_concept.get_prop("body"), BuiltinConcepts.LIST)
 
-    def_func = tree_as_concept.get_prop("body")[0]
+    def_func = tree_as_concept.get_prop("body").body[0]
     assert sheerka.isinstance(def_func, BuiltinConcepts.GENERIC_NODE)
     assert def_func.node_type == "FunctionDef"
     assert def_func.parent == NodeParent(tree_as_concept, "body")
@@ -54,27 +54,27 @@ def my_function(a,b):
 
     def_func_args_real_args = def_func_args.get_prop("args")
     assert sheerka.isinstance(def_func_args_real_args, BuiltinConcepts.LIST)
-    assert len(def_func_args_real_args) == 2
+    assert len(def_func_args_real_args.body) == 2
 
-    assert sheerka.isinstance(def_func_args_real_args[0], BuiltinConcepts.GENERIC_NODE)
-    assert def_func_args_real_args[0].node_type == "arg"
-    assert def_func_args_real_args[0].parent == NodeParent(def_func_args, "args")
-    assert def_func_args_real_args[0].get_prop("arg") == "a"
-    assert sheerka.isinstance(def_func_args_real_args[1], BuiltinConcepts.GENERIC_NODE)
-    assert def_func_args_real_args[1].node_type == "arg"
-    assert def_func_args_real_args[1].parent == NodeParent(def_func_args, "args")
-    assert def_func_args_real_args[1].get_prop("arg") == "b"
+    assert sheerka.isinstance(def_func_args_real_args.body[0], BuiltinConcepts.GENERIC_NODE)
+    assert def_func_args_real_args.body[0].node_type == "arg"
+    assert def_func_args_real_args.body[0].parent == NodeParent(def_func_args, "args")
+    assert def_func_args_real_args.body[0].get_prop("arg") == "a"
+    assert sheerka.isinstance(def_func_args_real_args.body[1], BuiltinConcepts.GENERIC_NODE)
+    assert def_func_args_real_args.body[1].node_type == "arg"
+    assert def_func_args_real_args.body[1].parent == NodeParent(def_func_args, "args")
+    assert def_func_args_real_args.body[1].get_prop("arg") == "b"
 
     def_fun_body = def_func.get_prop("body")
     assert sheerka.isinstance(def_fun_body, BuiltinConcepts.LIST)
-    assert len(def_fun_body) == 2
+    assert len(def_fun_body.body) == 2
 
-    def_fun_body_for = def_fun_body[0]
+    def_fun_body_for = def_fun_body.body[0]
     assert sheerka.isinstance(def_fun_body_for, BuiltinConcepts.GENERIC_NODE)
     assert def_fun_body_for.node_type == "For"
     assert def_fun_body_for.parent == NodeParent(def_func, "body")
 
-    def_fun_body_return = def_fun_body[1]
+    def_fun_body_return = def_fun_body.body[1]
     assert sheerka.isinstance(def_fun_body_return, BuiltinConcepts.GENERIC_NODE)
     assert def_fun_body_return.node_type == "Return"
     assert def_fun_body_return.parent == NodeParent(def_func, "body")

tests/core/test_builtin_helpers.py

@@ -134,6 +134,7 @@ class TestBuiltinHelpers(TestUsingMemoryBasedSheerka):
         ("a == 1 or b == 2", ["b"], [], ["b == 2"]),
         ("a == 1 or b == 2", ["a", "b"], [], ["a == 1 or b == 2"]),
         ("predicate(a,c) or predicate(b,c)", ["a", "b"], [], ["predicate(a,c) or predicate(b,c)"]),
+        ("a < 1 and a > b", ["a"], [], ["a < 1 and a > b"]),
     ])
     def test_i_can_extract_predicates(self, expression, vars_to_include, vars_to_exclude, expected_expr):
         sheerka = self.get_sheerka()

tests/core/test_sheerka.py

@@ -38,12 +38,12 @@ class TestSheerka(TestUsingFileBasedSheerka):
             assert isinstance(sheerka.cache_by_key[key], concept_class)
 
     def test_builtin_concepts_can_be_updated(self):
-        sheerka = self.get_sheerka(False, False)
+        sheerka = self.get_sheerka(use_dict=False, skip_builtins_in_db=False)
         loaded_sheerka = sheerka.get(BuiltinConcepts.SHEERKA)
         loaded_sheerka.metadata.desc = "I have a description"
         sheerka.sdp.modify("Test", sheerka.CONCEPTS_ENTRY, loaded_sheerka.key, loaded_sheerka)
 
-        sheerka = self.get_sheerka(False, False)
+        sheerka = self.get_sheerka(use_dict=False, skip_builtins_in_db=False)
         loaded_sheerka = sheerka.get(BuiltinConcepts.SHEERKA)
 
         assert loaded_sheerka.metadata.desc == "I have a description"
@@ -233,7 +233,7 @@ class TestSheerka(TestUsingFileBasedSheerka):
         assert sheerka.value(concept, reduce_simple_list) == expected
 
     def test_list_of_concept_is_sorted_by_id(self):
-        sheerka = self.get_sheerka(False, False)
+        sheerka = self.get_sheerka(use_dict=False, skip_builtins_in_db=False)
         concepts = sheerka.concepts()
 
         assert concepts[0].id < concepts[-1].id

tests/evaluators/test_EvalEvaluator.py

@@ -70,3 +70,21 @@ class TestEvalEvaluator(TestUsingMemoryBasedSheerka):
             False,
             context.sheerka.new(BuiltinConcepts.CONCEPT_EVAL_REQUESTED))
         assert evaluated.parents == [eval_requested]
+
+    def test_i_can_evaluate_sets(self):
+        sheerka, context, foo, bar, baz, number = self.init_concepts(
+            Concept("foo"),
+            Concept("bar"),
+            Concept("baz"),
+            Concept("number"))
+        sheerka.sets_handler.add_concepts_to_set(context, [foo, bar, baz], number)
+
+        return_values = [retval(number), eval_requested]
+
+        evaluator = EvalEvaluator()
+        evaluator.matches(context, return_values)
+        evaluated = evaluator.eval(context, return_values)
+
+        assert len(evaluated) == 1
+        assert evaluated[0].status
+        assert evaluated[0].body == [foo, bar, baz]

tests/non_reg/test_sheerka_non_reg.py

@@ -255,7 +255,7 @@ as:
         assert isinstance(res[0].value.body, list)
 
     def test_i_can_create_concept_with_bnf_definition(self):
-        sheerka = self.get_sheerka(False, False)
+        sheerka = self.get_sheerka(use_dict=False, skip_builtins_in_db=False)
         a = Concept("a")
         sheerka.add_in_cache(a)
         sheerka.concepts_definition_cache = {a: OrderedChoice("one", "two")}
@@ -317,10 +317,10 @@ as:
         Same test then before,
         but make sure that the BNF are correctly persisted and loaded
         """
-        sheerka = self.get_sheerka(False)
+        sheerka = self.get_sheerka(use_dict=False)
         concept_a = sheerka.evaluate_user_input("def concept a from bnf 'one' 'two'")[0].body.body
 
-        res = self.get_sheerka(False).evaluate_user_input("one two")
+        res = self.get_sheerka(use_dict=False).evaluate_user_input("one two")
         assert len(res) == 1
         assert res[0].status
         assert sheerka.isinstance(res[0].value, concept_a)
@@ -328,12 +328,12 @@ as:
         # add another bnf definition
         concept_b = sheerka.evaluate_user_input("def concept b from bnf a 'three'")[0].body.body
 
-        res = self.get_sheerka(False).evaluate_user_input("one two")  # previous one still works
+        res = self.get_sheerka(use_dict=False).evaluate_user_input("one two")  # previous one still works
         assert len(res) == 1
         assert res[0].status
         assert sheerka.isinstance(res[0].value, concept_a)
 
-        res = self.get_sheerka(False).evaluate_user_input("one two three")  # new one works
+        res = self.get_sheerka(use_dict=False).evaluate_user_input("one two three")  # new one works
         assert len(res) == 1
         assert res[0].status
         assert sheerka.isinstance(res[0].value, concept_b)

tests/sheerkapickle/test_SheerkaPickler.py

@@ -151,15 +151,6 @@ class TestSheerkaPickler(TestUsingFileBasedSheerka):
         decoded = SheerkaUnpickler(sheerka).restore(flatten)
         assert decoded == obj
 
-    def test_serialize_concept(self):
-        sheerka = self.get_sheerka()
-
-        foo = Concept("doo")
-        flatten = SheerkaPickler(sheerka).flatten(foo)
-        restored = SheerkaUnpickler(sheerka).restore(flatten)
-
-        assert restored == foo
-
     def test_i_do_not_encode_logger(self):
         sheerka = self.get_sheerka()
 

tests/sheerkapickle/test_sheerka_handlers.py

@@ -10,85 +10,98 @@ from sdp.sheerkaDataProvider import Event
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
 
 
+def set_full_serialization(concept):
+    concept.metadata.full_serialization = True
+    return concept
+
+
 class TestSheerkaPickleHandler(TestUsingMemoryBasedSheerka):
 
     def test_i_can_encode_decode_unknown_concept_metadata(self):
         sheerka = self.get_sheerka()
 
-        concept = Concept(name="foo", key="my_key")
+        concept = set_full_serialization(Concept(name="foo", key="my_key"))
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.key": "my_key"}'
         assert decoded == concept
 
-        concept = Concept("foo", is_builtin=True, is_unique=True)
+        concept = set_full_serialization(Concept("foo", is_builtin=True, is_unique=True))
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.is_builtin": true, "meta.is_unique": true}'
 
-        concept = Concept("foo", body="my_body")
+        concept = set_full_serialization(Concept("foo", body="my_body"))
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.body": "my_body"}'
 
-        concept = Concept("foo", pre="my_pre")
+        concept = set_full_serialization(Concept("foo", pre="my_pre"))
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.pre": "my_pre"}'
 
-        concept = Concept("foo", post="my_post")
+        concept = set_full_serialization(Concept("foo", post="my_post"))
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.post": "my_post"}'
 
-        concept = Concept("foo", where="my_where")
+        concept = set_full_serialization(Concept("foo", where="my_where"))
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.where": "my_where"}'
 
-        concept = Concept("foo").def_prop("a", "value_a").def_prop("b", "value_b")
+        concept = set_full_serialization(Concept("foo").def_prop("a", "value_a").def_prop("b", "value_b"))
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
 
+        concept = Concept("foo").init_key()
+        sheerka.create_new_concept(self.get_context(sheerka), concept)
+        concept.metadata.full_serialization = True
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.key": "foo", "meta.id": "1001"}'
+
     def test_i_can_encode_decode_unknown_concept_values(self):
         sheerka = self.get_sheerka()
 
-        concept = Concept("foo")
+        concept = set_full_serialization(Concept("foo"))
         concept.values[ConceptParts.PRE] = 10  # an int
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "pre": 10}'
 
-        concept = Concept("foo")
-        concept.values[ConceptParts.POST] = 'a string'  # an int
+        concept = set_full_serialization(Concept("foo"))
+        concept.values[ConceptParts.POST] = 'a string'  # an string
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "post": "a string"}'
 
-        concept = Concept("foo")
+        concept = set_full_serialization(Concept("foo"))
         concept.values[ConceptParts.WHERE] = ['a string', 3.14]  # a list
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "where": ["a string", 3.14]}'
 
-        concept = Concept("foo")
+        concept = set_full_serialization(Concept("foo"))
         concept.values[ConceptParts.WHERE] = ('a string', 3.14)  # a tuple
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "where": {"_sheerka/tuple": ["a string", 3.14]}}'
 
-        concept = Concept("foo")
-        concept.values[ConceptParts.BODY] = Concept("foo", body="foo_body")
+        concept = set_full_serialization(Concept("foo"))
+        concept.values[ConceptParts.BODY] = set_full_serialization(Concept("foo", body="foo_body"))
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
@@ -97,28 +110,28 @@ class TestSheerkaPickleHandler(TestUsingMemoryBasedSheerka):
     def test_i_can_encode_decode_unknown_concept_properties(self):
         sheerka = self.get_sheerka()
 
-        concept = Concept("foo")
+        concept = set_full_serialization(Concept("foo"))
         concept.set_prop("a", "value_a")  # string
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "props": [["a", "value_a"]]}'
 
-        concept = Concept("foo")
+        concept = set_full_serialization(Concept("foo"))
         concept.set_prop("a", 10)  # int
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "props": [["a", 10]]}'
 
-        concept = Concept("foo")
-        concept.set_prop("a", Concept("bar"))  # another concept
+        concept = set_full_serialization(Concept("foo"))
+        concept.set_prop("a", set_full_serialization(Concept("bar")))  # another concept
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "props": [["a", {"_sheerka/obj": "core.concept.Concept", "meta.name": "bar"}]]}'
 
-        concept = Concept("foo")
+        concept = set_full_serialization(Concept("foo"))
         concept.set_prop("a", "a").set_prop("b", "b")  # at least two props
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
@@ -138,19 +151,38 @@ class TestSheerkaPickleHandler(TestUsingMemoryBasedSheerka):
         assert decoded == ref_concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "concept/id": ["my_key", "1001"]}'
 
+        # same test, modify a value and check if this modification is correctly saved
         concept = Concept().update_from(sheerka.get_by_id(ref_concept.id))
-        concept.set_metadata_value(ConceptParts.BODY, Concept("bar"))
+        concept.set_metadata_value(ConceptParts.BODY, set_full_serialization(Concept("bar")))
         to_string = sheerkapickle.encode(sheerka, concept)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == concept
         assert to_string == '{"_sheerka/obj": "core.concept.Concept", "concept/id": ["my_key", "1001"], "body": {"_sheerka/obj": "core.concept.Concept", "meta.name": "bar"}}'
 
+    def test_i_can_encode_decode_when_property_is_a_concept(self):
+        sheerka = self.get_sheerka()
+
+        foo = Concept("foo").init_key()
+        sheerka.create_new_concept(self.get_context(sheerka), foo)
+
+        concept = Concept("my_name").init_key()
+        sheerka.create_new_concept(self.get_context(sheerka), concept)
+        concept.def_prop(foo, "a value")
+        concept.metadata.full_serialization = True
+
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "my_name", "meta.key": "my_name", ' + \
+               '"meta.props": [{"_sheerka/tuple": [{"_sheerka/obj": "core.concept.Concept", "concept/id": ["foo", "1001"]}, "a value"]}], ' + \
+               '"meta.id": "1002", "props": [[{"_sheerka/id": 1}, null]]}'
+
     def test_i_can_manage_reference_of_the_same_object(self):
         sheerka = self.get_sheerka()
 
-        concept_ref = Concept("foo")
+        concept_ref = set_full_serialization(Concept("foo"))
 
-        concept = Concept("bar")
+        concept = set_full_serialization(Concept("bar"))
         concept.set_metadata_value(ConceptParts.PRE, concept_ref)
         concept.set_metadata_value(ConceptParts.BODY, concept_ref)
 
@@ -189,7 +221,7 @@ class TestSheerkaPickleHandler(TestUsingMemoryBasedSheerka):
         to_string = sheerkapickle.encode(sheerka, ret_val)
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == ret_val
-        assert to_string == '{"_sheerka/obj": "core.builtin_concepts.ReturnValueConcept", "who": "who", "status": true, "value": 10}'
+        assert to_string == '{"_sheerka/obj": "core.builtin_concepts.ReturnValueConcept", "concept/id": ["__RETURN_VALUE", null], "who": "who", "status": true, "value": 10}'
 
     def test_i_can_encode_decode_return_value_with_parent(self):
         sheerka = self.get_sheerka()
@@ -202,13 +234,14 @@ class TestSheerkaPickleHandler(TestUsingMemoryBasedSheerka):
         decoded = sheerkapickle.decode(sheerka, to_string)
         assert decoded == ret_val
         assert decoded.parents == ret_val.parents
-        parents_str = '[{"_sheerka/obj": "core.builtin_concepts.ReturnValueConcept", "who": "parent_who", "status": true, "value": "10"}, {"_sheerka/id": 1}]'
-        assert to_string == '{"_sheerka/obj": "core.builtin_concepts.ReturnValueConcept", "who": "who", "status": true, "value": 10, "parents": ' + parents_str + '}'
+        id_str = ', "concept/id": ["__RETURN_VALUE", null]'
+        parents_str = '[{"_sheerka/obj": "core.builtin_concepts.ReturnValueConcept"' + id_str + ', "who": "parent_who", "status": true, "value": "10"}, {"_sheerka/id": 1}]'
+        assert to_string == '{"_sheerka/obj": "core.builtin_concepts.ReturnValueConcept"' + id_str + ', "who": "who", "status": true, "value": 10, "parents": ' + parents_str + '}'
 
     def test_i_can_encode_decode_return_values_with_complex_body(self):
         sheerka = self.get_sheerka()
 
-        ret_val = sheerka.ret("who", True, Concept("foo", body="bar"))
+        ret_val = sheerka.ret("who", True, set_full_serialization(Concept("foo", body="bar")))
 
         to_string = sheerkapickle.encode(sheerka, ret_val)
         decoded = sheerkapickle.decode(sheerka, to_string)
@@ -239,9 +272,9 @@ class TestSheerkaPickleHandler(TestUsingMemoryBasedSheerka):
 
         context = ExecutionContext("who", Event("xxx"), sheerka, "my desc")
         input_list = [ReturnValueConcept("who", True, 10), ReturnValueConcept("who2", False, 20)]
-        context.inputs = {"a": input_list, "b": Concept("foo")}
-        context.values = {"c": input_list, "d": Concept("bar")}
-        context.obj = Concept("baz")
+        context.inputs = {"a": input_list, "b": set_full_serialization(Concept("foo"))}
+        context.values = {"c": input_list, "d": set_full_serialization(Concept("bar"))}
+        context.obj = set_full_serialization(Concept("baz"))
         context.push("who3", "sub_child1")
         context.push("who4", "sub_child2")
 
@@ -278,7 +311,7 @@ class TestSheerkaPickleHandler(TestUsingMemoryBasedSheerka):
     def test_encode_simple_concept(self):
         sheerka = self.get_sheerka()
 
-        foo = Concept("foo")
+        foo = set_full_serialization(Concept("foo"))
         to_string = sheerkapickle.encode(sheerka, foo)
         decoded = sheerkapickle.decode(sheerka, to_string)