326 lines
17 KiB
Python
326 lines
17 KiB
Python
import pytest
|
|
|
|
import sheerkapickle
|
|
from base import BaseTest
|
|
from core.concept import Concept
|
|
|
|
|
|
def set_full_serialization(concept):
|
|
concept.get_metadata().full_serialization = True
|
|
return concept
|
|
|
|
|
|
@pytest.mark.skip("Handler are not implemented")
|
|
class TestSheerkaPickleHandler(BaseTest):
|
|
|
|
def test_i_can_encode_decode_unknown_concept_metadata(self, 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.define_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.define_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("who3", BuiltinConcepts.EVALUATING_CONCEPT, c, desc="sub_child1")
|
|
context.push("who4", BuiltinConcepts.EVALUATING_ATTRIBUTE, "a", 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"]]}'
|