Sheerka-Old/tests/sheerkapickle/test_sheerka_handlers.py

import sheerkapickle
from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept
from core.concept import Concept, ConceptParts
from core.rule import Rule
from core.sheerka.ExecutionContext import ExecutionContext
from core.tokenizer import Tokenizer
from evaluators.ConceptEvaluator import ConceptEvaluator
from parsers.DefConceptParser import DefConceptParser
from sdp.sheerkaDataProvider import Event

from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


def set_full_serialization(concept):
    concept.get_metadata().full_serialization = True
    return concept


class TestSheerkaPickleHandler(TestUsingMemoryBasedSheerka):
    user_input_id = 0
    return_value_id = 0

    @classmethod
    def setup(cls):
        sheerka = cls().get_sheerka()
        cls.user_input_id = sheerka.get_by_key("__USER_INPUT").id
        cls.return_value_id = sheerka.get_by_key("__RETURN_VALUE").id

    def test_i_can_encode_decode_unknown_concept_metadata(self):
        sheerka = self.get_sheerka()

        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 = 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 = 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 = 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 = 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 = 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 = set_full_serialization(Concept("foo").def_var("a", "value_a").def_var("b", "value_b"))
        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.variables": [["a", "value_a"], ["b", "value_b"]], "values": [["a", {"_sheerka/custom": "**NotInit**"}], ["b", {"_sheerka/id": 1}]]}'

        concept = Concept("foo").init_key()
        sheerka.create_new_concept(self.get_context(sheerka), concept)
        concept.get_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 = set_full_serialization(Concept("foo"))
        concept.set_value(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", "values": [["#pre#", 10]]}'

        concept = set_full_serialization(Concept("foo"))
        concept.set_value(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", "values": [["#post#", "a string"]]}'

        concept = set_full_serialization(Concept("foo"))
        concept.set_value(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", "values": [["#where#", ["a string", 3.14]]]}'

        concept = set_full_serialization(Concept("foo"))
        concept.set_value(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", "values": [["#where#", {"_sheerka/tuple": ["a string", 3.14]}]]}'

        concept = set_full_serialization(Concept("foo"))
        concept.set_value(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
        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "values": [["#body#", {"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.body": "foo_body"}]]}'

    def test_i_can_encode_decode_unknown_concept_variables(self):
        sheerka = self.get_sheerka()

        concept = set_full_serialization(Concept("foo"))
        concept.set_value("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", "values": [["a", "value_a"]]}'

        concept = set_full_serialization(Concept("foo"))
        concept.set_value("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", "values": [["a", 10]]}'

        concept = set_full_serialization(Concept("foo"))
        concept.set_value("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", "values": [["a", {"_sheerka/obj": "core.concept.Concept", "meta.name": "bar"}]]}'

        concept = set_full_serialization(Concept("foo"))
        concept.set_value("a", "a").set_value("b", "b")  # at least two variables
        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", "values": [["a", "a"], ["b", "b"]]}'

    def test_i_can_encode_decode_known_concepts(self):
        sheerka = self.get_sheerka()

        ref_concept = Concept("my_name", True, True, "my_key", "my_body", "my_where", "my_pre", "my_post", "my_def")
        ref_concept.def_var("a", "value_a").def_var("b", "value_b")

        sheerka.create_new_concept(self.get_context(sheerka), ref_concept)

        to_string = sheerkapickle.encode(sheerka, ref_concept)
        decoded = sheerkapickle.decode(sheerka, to_string)
        assert decoded == ref_concept
        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "concept/id": "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_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": "1001", "values": [["#body#", {"_sheerka/obj": "core.concept.Concept", "meta.name": "bar"}]]}'

    def test_i_can_manage_reference_of_the_same_object(self):
        sheerka = self.get_sheerka()

        concept_ref = set_full_serialization(Concept("foo"))

        concept = set_full_serialization(Concept("bar"))
        concept.set_value(ConceptParts.PRE, concept_ref)
        concept.set_value(ConceptParts.BODY, concept_ref)

        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": "bar", "values": [["#pre#", {"_sheerka/obj": "core.concept.Concept", "meta.name": "foo"}], ["#body#", {"_sheerka/id": 1}]]}'

    def test_i_can_encode_decode_user_input(self):
        sheerka = self.get_sheerka()

        user_input = sheerka.new(BuiltinConcepts.USER_INPUT, body="my_text", user_name="my_user_name")

        to_string = sheerkapickle.encode(sheerka, user_input)
        decoded = sheerkapickle.decode(sheerka, to_string)
        assert decoded == user_input
        assert to_string == f'{{"_sheerka/obj": "core.builtin_concepts.UserInputConcept", "concept/id": ["__USER_INPUT", "{self.user_input_id}"], "user_name": "my_user_name", "text": "my_text"}}'

    def test_i_can_encode_decode_user_input_when_tokens(self):
        sheerka = self.get_sheerka()

        text = "I have 'a complicated' 10 text"
        tokens = list(Tokenizer(text))
        user_input = sheerka.new(BuiltinConcepts.USER_INPUT, body=tokens, user_name="my_user_name")

        to_string = sheerkapickle.encode(sheerka, user_input)
        decoded = sheerkapickle.decode(sheerka, to_string)
        assert decoded == sheerka.new(BuiltinConcepts.USER_INPUT, body=text, user_name="my_user_name")
        assert to_string == f'{{"_sheerka/obj": "core.builtin_concepts.UserInputConcept", "concept/id": ["__USER_INPUT", "{self.user_input_id}"], "user_name": "my_user_name", "text": "{text}"}}'

    def test_i_can_encode_decode_return_value(self):
        sheerka = self.get_sheerka()

        ret_val = sheerka.ret("who", True, 10)

        to_string = sheerkapickle.encode(sheerka, ret_val)
        decoded = sheerkapickle.decode(sheerka, to_string)
        assert decoded == ret_val
        assert to_string == f'{{"_sheerka/obj": "core.builtin_concepts.ReturnValueConcept", "concept/id": ["__RETURN_VALUE", "{self.return_value_id}"], "who": "who", "status": true, "value": 10}}'

    def test_i_can_encode_decode_return_value_with_parent(self):
        sheerka = self.get_sheerka()

        ret_val = sheerka.ret("who", True, 10)
        ret_val_parent = sheerka.ret("parent_who", True, "10")
        ret_val.parents = [ret_val_parent, ret_val_parent]

        to_string = sheerkapickle.encode(sheerka, ret_val)
        decoded = sheerkapickle.decode(sheerka, to_string)
        assert decoded == ret_val
        assert decoded.parents == ret_val.parents
        id_str = f', "concept/id": ["__RETURN_VALUE", "{self.return_value_id}"]'
        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, set_full_serialization(Concept("foo", body="bar")))

        to_string = sheerkapickle.encode(sheerka, ret_val)
        decoded = sheerkapickle.decode(sheerka, to_string)
        assert decoded == ret_val

    def test_i_can_encode_decode_return_values_from_concepts_parsers_or_evaluators(self):
        sheerka = self.get_sheerka()

        foo = Concept("foo")
        sheerka.set_id_if_needed(foo, False)
        ret_val = sheerka.ret(foo, True, 10)
        to_string = sheerkapickle.encode(sheerka, ret_val)
        decoded = sheerkapickle.decode(sheerka, to_string)
        assert decoded == sheerka.ret("c:1001:", True, 10)

        ret_val = sheerka.ret(DefConceptParser(), True, 10)
        to_string = sheerkapickle.encode(sheerka, ret_val)
        decoded = sheerkapickle.decode(sheerka, to_string)
        assert decoded == sheerka.ret("parsers.DefConcept", True, 10)

        ret_val = sheerka.ret(ConceptEvaluator(), True, 10)
        to_string = sheerkapickle.encode(sheerka, ret_val)
        decoded = sheerkapickle.decode(sheerka, to_string)
        assert decoded == sheerka.ret("evaluators.Concept", True, 10)

    def test_i_can_encode_decode_execution_context(self):
        sheerka = self.get_sheerka()
        c = Concept("foo").def_var("a")
        context = ExecutionContext("who", Event("xxx"), sheerka, BuiltinConcepts.EVALUATE_CONCEPT, c, "my desc")
        input_list = [ReturnValueConcept("who", True, 10), ReturnValueConcept("who2", False, 20)]
        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(BuiltinConcepts.EVALUATING_CONCEPT, c, who="who3", desc="sub_child1")
        context.push(BuiltinConcepts.EVALUATING_ATTRIBUTE, "a", who="who4", desc="sub_child2")

        to_string = sheerkapickle.encode(sheerka, context)
        decoded = sheerkapickle.decode(sheerka, to_string)
        assert decoded == context

    def test_complicated_execution_context(self):
        sheerka = self.get_sheerka(skip_builtins_in_db=False)

        text = "def concept one as 1"
        execution_context = ExecutionContext("s", Event(), sheerka, BuiltinConcepts.NOP, None, f"Evaluating '{text}'")
        user_input = sheerka.ret("s", True, sheerka.new(BuiltinConcepts.USER_INPUT, body=text, user_name="n"))
        reduce_requested = sheerka.ret("s", True, sheerka.new(BuiltinConcepts.REDUCE_REQUESTED))

        steps = [
            BuiltinConcepts.BEFORE_PARSING,
            BuiltinConcepts.PARSING,
            BuiltinConcepts.AFTER_PARSING,
            BuiltinConcepts.BEFORE_EVALUATION,
            BuiltinConcepts.EVALUATION,
            BuiltinConcepts.AFTER_EVALUATION
        ]

        ret = sheerka.execute(execution_context, [user_input, reduce_requested], steps)
        execution_context.add_values(return_values=ret)

        to_string = sheerkapickle.encode(sheerka, execution_context)
        decoded = sheerkapickle.decode(sheerka, to_string)

        return_value = decoded.values["return_values"][0].value
        assert sheerka.isinstance(return_value, BuiltinConcepts.NEW_CONCEPT)

    def test_encode_simple_concept(self):
        sheerka = self.get_sheerka()

        foo = set_full_serialization(Concept("foo"))
        to_string = sheerkapickle.encode(sheerka, foo)
        decoded = sheerkapickle.decode(sheerka, to_string)

        assert decoded == foo

    def test_i_can_encode_decode_rule(self):
        sheerka = self.get_sheerka()

        rule = Rule("print", "my rule", "True", "Hello world")
        rule.metadata.id = "1"

        to_string = sheerkapickle.encode(sheerka, rule)
        decoded = sheerkapickle.decode(sheerka, to_string)

        assert to_string == '{"_sheerka/obj": "core.rule.Rule", "rule/id": "1", "name": "my rule", "predicate": "True", "action_type": "print", "action": "Hello world"}'
        assert decoded == rule

    def test_i_can_encode_decode_dynamic_concept(self):
        sheerka, context, foo = self.init_concepts("foo", global_truth=True, create_new=True)
        sheerka.set_attr(context, foo, "attr", "attr_value")
        sheerka.set_property(context, foo, "prop", "prop_value", all_concepts=True)

        foo_instance = sheerka.new(foo)
        dynamic_foo = sheerka.new_dynamic(foo_instance,
                                          "SUFFIX",
                                          "new_name",
                                          props={"new_prop": "value"},
                                          attrs={"new_attr": "value"})

        to_string = sheerkapickle.encode(sheerka, dynamic_foo)
        decoded = sheerkapickle.decode(sheerka, to_string)

        assert decoded == dynamic_foo
        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "concept/id": "1001-SUFFIX", "meta.name": "new_name", "meta.key": "new_name", "meta.props": {"prop": "prop_value", "new_prop": "value"}, "meta.id": "1001-SUFFIX", "values": [["new_attr", "value"]]}'