Refactored ExecutionContext serialization (added sheerkapickle) and added History management
This commit is contained in:
@@ -2,7 +2,7 @@ import pytest
|
||||
|
||||
from core.builtin_concepts import BuiltinConcepts
|
||||
from core.concept import Concept
|
||||
from core.sheerka.Sheerka import ExecutionContext
|
||||
from core.sheerka.ExecutionContext import ExecutionContext
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
from core.sheerka.Services.SheerkaHistoryManager import hist
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
|
||||
class TestSheerkaHistoryManager(TestUsingMemoryBasedSheerka):
|
||||
def test_i_can_retrieve_history(self):
|
||||
sheerka = self.get_sheerka(skip_builtins_in_db=False)
|
||||
|
||||
sheerka.evaluate_user_input("def concept one as 1")
|
||||
sheerka.evaluate_user_input("one")
|
||||
sheerka.evaluate_user_input("xxx")
|
||||
sheerka.evaluate_user_input("def concept two as 2")
|
||||
sheerka.evaluate_user_input("two")
|
||||
sheerka.evaluate_user_input("def concept three as 3")
|
||||
sheerka.evaluate_user_input("three")
|
||||
sheerka.evaluate_user_input("def concept four as 4")
|
||||
sheerka.evaluate_user_input("four")
|
||||
sheerka.evaluate_user_input("def concept five as 5")
|
||||
sheerka.evaluate_user_input("five")
|
||||
|
||||
h = list(sheerka.history(-1)) # all
|
||||
assert h == [
|
||||
hist("five", True),
|
||||
hist("def concept five as 5", True),
|
||||
hist("four", True),
|
||||
hist("def concept four as 4", True),
|
||||
hist("three", True),
|
||||
hist("def concept three as 3", True),
|
||||
hist("two", True),
|
||||
hist("def concept two as 2", True),
|
||||
hist("xxx", False),
|
||||
hist("one", True),
|
||||
hist("def concept one as 1", True),
|
||||
hist("Initializing Sheerka.", True)]
|
||||
|
||||
h = list(sheerka.history(2))
|
||||
assert h == [
|
||||
hist("two", True),
|
||||
hist("def concept two as 2", True)
|
||||
]
|
||||
|
||||
h = list(sheerka.history(2, 2))
|
||||
assert h == [
|
||||
hist("xxx", False),
|
||||
hist("one", True),
|
||||
]
|
||||
|
||||
h = list(sheerka.history(-1))
|
||||
assert h == [
|
||||
hist("xxx", False),
|
||||
hist("one", True),
|
||||
]
|
||||
@@ -1,318 +0,0 @@
|
||||
from core.builtin_concepts import BuiltinConcepts
|
||||
from core.concept import Concept, ConceptParts
|
||||
from core.sheerka.ExecutionContext import ExecutionContext
|
||||
from core.sheerka_transform import SheerkaTransform, OBJ_TYPE_KEY, SheerkaTransformType, OBJ_ID_KEY
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
|
||||
class TestSheerkaTransform(TestUsingMemoryBasedSheerka):
|
||||
def test_i_can_transform_an_unknown_concept(self):
|
||||
sheerka = self.get_sheerka()
|
||||
|
||||
foo = Concept("foo", body="body")
|
||||
concept_with_sub = Concept("concept_with_sub", body=foo)
|
||||
|
||||
concept = Concept(
|
||||
name="concept_name",
|
||||
is_builtin=True,
|
||||
is_unique=True,
|
||||
key="concept_key",
|
||||
body=concept_with_sub,
|
||||
where=[foo, 1, "1", True, 1.0],
|
||||
pre=foo,
|
||||
post=None, # will not appear
|
||||
definition="it is a definition",
|
||||
definition_type="def type",
|
||||
desc="this this the desc"
|
||||
).def_prop("a", "10").def_prop("b", "foo").def_prop("c", "concept_with_sub")
|
||||
|
||||
# add values and props
|
||||
concept.values[ConceptParts.BODY] = Concept().update_from(concept_with_sub).auto_init()
|
||||
concept.values[ConceptParts.WHERE] = [foo, 1, "1", True, 1.0]
|
||||
concept.values[ConceptParts.PRE] = Concept().update_from(foo).auto_init()
|
||||
concept.values[ConceptParts.POST] = "a value for POST"
|
||||
concept.set_prop("a", 10).set_prop("b", foo).set_prop("c", concept_with_sub)
|
||||
|
||||
st = SheerkaTransform(sheerka)
|
||||
to_dict = st.to_dict(concept)
|
||||
|
||||
assert to_dict == {
|
||||
OBJ_TYPE_KEY: SheerkaTransformType.Concept,
|
||||
OBJ_ID_KEY: 0,
|
||||
'meta.name': 'concept_name',
|
||||
'meta.key': 'concept_key',
|
||||
'meta.is_builtin': True,
|
||||
'meta.is_unique': True,
|
||||
'meta.definition': 'it is a definition',
|
||||
'meta.definition_type': 'def type',
|
||||
'meta.desc': 'this this the desc',
|
||||
'meta.where': [{OBJ_TYPE_KEY: SheerkaTransformType.Concept,
|
||||
OBJ_ID_KEY: 1,
|
||||
'meta.body': 'body',
|
||||
'meta.name': 'foo'}, 1, '1', True, 1.0],
|
||||
'meta.pre': {OBJ_TYPE_KEY: SheerkaTransformType.Reference, OBJ_ID_KEY: 1},
|
||||
'meta.body': {
|
||||
'__type__': SheerkaTransformType.Concept,
|
||||
'__id__': 2,
|
||||
'meta.name': 'concept_with_sub',
|
||||
'meta.body': {
|
||||
'__type__': SheerkaTransformType.Reference,
|
||||
'__id__': 1}},
|
||||
'meta.props': [['a', '10'], ['b', 'foo'], ['c', 'concept_with_sub']],
|
||||
'pre': {'__type__': SheerkaTransformType.Concept,
|
||||
'__id__': 4,
|
||||
'meta.body': 'body',
|
||||
'meta.name': 'foo',
|
||||
'body': 'body'},
|
||||
'post': "a value for POST",
|
||||
'body': {'__type__': SheerkaTransformType.Concept,
|
||||
'__id__': 3,
|
||||
'meta.body': {'__id__': 1, '__type__': SheerkaTransformType.Reference},
|
||||
'meta.name': 'concept_with_sub',
|
||||
'body': {'__id__': 1, '__type__': SheerkaTransformType.Reference}},
|
||||
'where': [{OBJ_TYPE_KEY: SheerkaTransformType.Reference, OBJ_ID_KEY: 1}, 1, '1', True, 1.0],
|
||||
'props': [('a', 10),
|
||||
('b', {OBJ_TYPE_KEY: SheerkaTransformType.Reference, OBJ_ID_KEY: 1}),
|
||||
('c', {OBJ_TYPE_KEY: SheerkaTransformType.Reference, OBJ_ID_KEY: 2})],
|
||||
}
|
||||
|
||||
def test_i_can_transform_unknown_concept_with_almost_same_value(self):
|
||||
sheerka = self.get_sheerka()
|
||||
concept = Concept("foo")
|
||||
|
||||
st = SheerkaTransform(sheerka)
|
||||
to_dict = st.to_dict(concept)
|
||||
|
||||
assert to_dict == {OBJ_TYPE_KEY: SheerkaTransformType.Concept, OBJ_ID_KEY: 0, 'meta.name': 'foo'}
|
||||
|
||||
def test_i_can_transform_known_concept_when_the_values_are_the_same(self):
|
||||
"""
|
||||
Values are the same means that we are serializing a concept which has kept all its default values
|
||||
There is not diff between the concept to serialize and the one which was registered with create_new_concept()
|
||||
We serialize only the id of the concept
|
||||
:return:
|
||||
"""
|
||||
sheerka = self.get_sheerka()
|
||||
|
||||
concept = Concept(
|
||||
name="concept_name",
|
||||
is_builtin=True,
|
||||
is_unique=False,
|
||||
key="concept_key",
|
||||
body="body definition",
|
||||
where="where definition",
|
||||
pre="pre definition",
|
||||
post="post definition",
|
||||
definition="it is a definition",
|
||||
definition_type="def type",
|
||||
desc="this this the desc"
|
||||
).def_prop("a").def_prop("b")
|
||||
sheerka.create_new_concept(self.get_context(sheerka), concept)
|
||||
|
||||
new_concept = sheerka.new(concept.key)
|
||||
st = SheerkaTransform(sheerka)
|
||||
to_dict = st.to_dict(new_concept)
|
||||
|
||||
assert to_dict == {OBJ_TYPE_KEY: SheerkaTransformType.Concept, OBJ_ID_KEY: 0, "id": "1001"}
|
||||
|
||||
def test_i_can_transform_known_concept_when_the_values_are_different(self):
|
||||
"""
|
||||
Values are the different means the concept was modified.
|
||||
It's different from the one which was registered with create_new_concept()
|
||||
We serialize only the differences
|
||||
:return:
|
||||
"""
|
||||
sheerka = self.get_sheerka()
|
||||
|
||||
concept = Concept(
|
||||
name="concept_name",
|
||||
is_builtin=True,
|
||||
is_unique=False,
|
||||
key="concept_key",
|
||||
body="body definition",
|
||||
where="where definition",
|
||||
pre="pre definition",
|
||||
post="post definition",
|
||||
definition="it is a definition",
|
||||
definition_type="def type",
|
||||
desc="this this the desc"
|
||||
).def_prop("a").def_prop("b")
|
||||
sheerka.create_new_concept(self.get_context(sheerka), concept)
|
||||
|
||||
new_concept = sheerka.new(concept.key, body="another", a=10, pre="another pre")
|
||||
st = SheerkaTransform(sheerka)
|
||||
to_dict = st.to_dict(new_concept)
|
||||
|
||||
assert to_dict == {
|
||||
OBJ_TYPE_KEY: SheerkaTransformType.Concept,
|
||||
OBJ_ID_KEY: 0,
|
||||
"id": "1001",
|
||||
'pre': 'another pre',
|
||||
"body": "another",
|
||||
'props': [('a', 10)]
|
||||
}
|
||||
|
||||
def test_i_can_transform_concept_with_circular_reference(self):
|
||||
sheerka = self.get_sheerka()
|
||||
foo = Concept("foo")
|
||||
bar = Concept("bar", body=foo)
|
||||
foo.metadata.body = bar
|
||||
|
||||
st = SheerkaTransform(sheerka)
|
||||
to_dict = st.to_dict(foo)
|
||||
|
||||
assert to_dict == {
|
||||
OBJ_TYPE_KEY: SheerkaTransformType.Concept,
|
||||
OBJ_ID_KEY: 0,
|
||||
'meta.name': 'foo',
|
||||
'meta.body': {OBJ_TYPE_KEY: SheerkaTransformType.Concept,
|
||||
OBJ_ID_KEY: 1,
|
||||
'meta.name': 'bar',
|
||||
'meta.body': {OBJ_TYPE_KEY: SheerkaTransformType.Reference,
|
||||
OBJ_ID_KEY: 0},
|
||||
},
|
||||
}
|
||||
|
||||
def test_i_can_transform_concept_with_circular_reference_2(self):
|
||||
sheerka = self.get_sheerka()
|
||||
foo = Concept("foo")
|
||||
bar = Concept("foo", body=foo)
|
||||
foo.metadata.body = bar
|
||||
|
||||
st = SheerkaTransform(sheerka)
|
||||
to_dict = st.to_dict(foo)
|
||||
|
||||
assert to_dict == {
|
||||
OBJ_TYPE_KEY: SheerkaTransformType.Concept,
|
||||
OBJ_ID_KEY: 0,
|
||||
'meta.name': 'foo',
|
||||
'meta.body': {OBJ_TYPE_KEY: SheerkaTransformType.Concept,
|
||||
OBJ_ID_KEY: 1,
|
||||
'meta.name': 'foo',
|
||||
'meta.body': {OBJ_TYPE_KEY: SheerkaTransformType.Reference,
|
||||
OBJ_ID_KEY: 0},
|
||||
},
|
||||
}
|
||||
|
||||
def test_i_can_transform_the_unknown_concept(self):
|
||||
sheerka = self.get_sheerka(False)
|
||||
|
||||
unknown = sheerka.new(BuiltinConcepts.UNKNOWN_CONCEPT)
|
||||
|
||||
st = SheerkaTransform(sheerka)
|
||||
to_dict = st.to_dict(unknown)
|
||||
|
||||
assert len(to_dict) == 3
|
||||
assert to_dict[OBJ_TYPE_KEY] == SheerkaTransformType.Concept
|
||||
assert to_dict[OBJ_ID_KEY] == 0
|
||||
assert "id" in to_dict
|
||||
|
||||
def test_i_can_transform_simple_execution_context(self):
|
||||
sheerka = self.get_sheerka()
|
||||
ExecutionContext.ids = {}
|
||||
context = ExecutionContext("requester", Event(), sheerka, 'this is the desc')
|
||||
|
||||
st = SheerkaTransform(sheerka)
|
||||
to_dict = st.to_dict(context)
|
||||
|
||||
assert to_dict == {
|
||||
OBJ_TYPE_KEY: SheerkaTransformType.ExecutionContext,
|
||||
OBJ_ID_KEY: 0,
|
||||
'_parent': None,
|
||||
'_id': 0,
|
||||
'_tab': '',
|
||||
'_bag': {},
|
||||
'_start': 0,
|
||||
'_stop': 0,
|
||||
'who': 'requester',
|
||||
'event': {OBJ_TYPE_KEY: SheerkaTransformType.Event, OBJ_ID_KEY: 1, 'digest': 'xxx'},
|
||||
'desc': 'this is the desc',
|
||||
'children': [],
|
||||
'preprocess': None,
|
||||
'inputs': {},
|
||||
'values': {},
|
||||
'obj': None,
|
||||
'concepts': {}
|
||||
}
|
||||
|
||||
def test_i_can_transform_list(self):
|
||||
sheerka = self.get_sheerka()
|
||||
ExecutionContext.ids = {}
|
||||
context = ExecutionContext("requester", Event(), sheerka, 'this is the desc')
|
||||
|
||||
st = SheerkaTransform(sheerka)
|
||||
to_dict = st.to_dict([context])
|
||||
|
||||
assert len(to_dict) == 1
|
||||
assert isinstance(to_dict, list)
|
||||
assert to_dict[0]["who"] == "requester"
|
||||
assert to_dict[0]["desc"] == "this is the desc"
|
||||
|
||||
def test_i_can_transform_set(self):
|
||||
sheerka = self.get_sheerka()
|
||||
ExecutionContext.ids = {}
|
||||
context = ExecutionContext("requester", Event(), sheerka, 'this is the desc')
|
||||
|
||||
st = SheerkaTransform(sheerka)
|
||||
to_dict = st.to_dict({context})
|
||||
|
||||
assert len(to_dict) == 1
|
||||
assert isinstance(to_dict, list)
|
||||
assert to_dict[0]["who"] == "requester"
|
||||
assert to_dict[0]["desc"] == "this is the desc"
|
||||
|
||||
def test_i_can_transform_dict(self):
|
||||
sheerka = self.get_sheerka()
|
||||
ExecutionContext.ids = {}
|
||||
context = ExecutionContext("requester", Event(), sheerka, 'this is the desc')
|
||||
known_concept = Concept("foo", body="foo").set_prop("a", "value_of_a").init_key()
|
||||
sheerka.create_new_concept(self.get_context(sheerka), known_concept)
|
||||
unknown_concept = Concept("bar")
|
||||
known = sheerka.new("foo")
|
||||
|
||||
bag = {
|
||||
"context": context,
|
||||
"known_concept": known_concept,
|
||||
"unknown_concept": unknown_concept,
|
||||
"True": True,
|
||||
"Number": 1.1,
|
||||
"String": "a string value",
|
||||
"None": None,
|
||||
unknown_concept: "hello",
|
||||
known: "world"
|
||||
}
|
||||
|
||||
st = SheerkaTransform(sheerka)
|
||||
to_dict = st.to_dict(bag)
|
||||
|
||||
assert isinstance(to_dict, dict)
|
||||
assert to_dict['Number'] == 1.1
|
||||
assert to_dict['String'] == 'a string value'
|
||||
assert to_dict['True']
|
||||
assert to_dict['None'] is None
|
||||
assert to_dict["context"][OBJ_TYPE_KEY] == SheerkaTransformType.ExecutionContext
|
||||
assert to_dict["known_concept"][OBJ_TYPE_KEY] == SheerkaTransformType.Concept
|
||||
assert to_dict["known_concept"]["id"] == '1001'
|
||||
assert to_dict["unknown_concept"][OBJ_TYPE_KEY] == SheerkaTransformType.Concept
|
||||
assert to_dict["(None)bar"] == "hello"
|
||||
assert to_dict["(1001)foo"] == "world"
|
||||
|
||||
def test_i_can_transform_when_circular_references(self):
|
||||
sheerka = self.get_sheerka()
|
||||
ExecutionContext.ids = {}
|
||||
context = ExecutionContext("requester", Event(), sheerka, 'this is the desc')
|
||||
context.push("another requester", "another desc")
|
||||
|
||||
st = SheerkaTransform(sheerka)
|
||||
to_dict = st.to_dict(context)
|
||||
|
||||
assert isinstance(to_dict, dict)
|
||||
assert to_dict[OBJ_TYPE_KEY] == SheerkaTransformType.ExecutionContext
|
||||
assert len(to_dict["children"]) == 1
|
||||
assert to_dict["children"][0][OBJ_TYPE_KEY] == SheerkaTransformType.ExecutionContext
|
||||
assert to_dict["children"][0]['_parent'][OBJ_TYPE_KEY] == SheerkaTransformType.Reference
|
||||
assert to_dict["children"][0]['_parent'][OBJ_ID_KEY] == 0
|
||||
assert to_dict["children"][0]['event'][OBJ_TYPE_KEY] == SheerkaTransformType.Reference
|
||||
assert to_dict["children"][0]['event'][OBJ_ID_KEY] == 1
|
||||
@@ -1,5 +1,6 @@
|
||||
import core.utils
|
||||
import pytest
|
||||
from core.concept import ConceptParts
|
||||
|
||||
from core.tokenizer import Token, TokenKind
|
||||
|
||||
@@ -130,6 +131,37 @@ def test_i_can_escape():
|
||||
assert actual == "hello \\'world\\' my friend"
|
||||
|
||||
|
||||
@pytest.mark.parametrize("text, expected_key, expected_id", [
|
||||
(None, None, None),
|
||||
(10, None, None),
|
||||
("", None, None),
|
||||
("xxx", None, None),
|
||||
(":c:", None, None),
|
||||
(":c:key", None, None),
|
||||
(":c:key:", "key", None),
|
||||
(":c:key:id", None, None),
|
||||
(":c:key:id:", "key", "id"),
|
||||
])
|
||||
def test_i_can_decode_concept_repr(text, expected_key, expected_id):
|
||||
k, i = core.utils.decode_concept(text)
|
||||
assert k == expected_key
|
||||
assert i == expected_id
|
||||
|
||||
|
||||
@pytest.mark.parametrize("text, expected", [
|
||||
(None, None),
|
||||
(10, None),
|
||||
("", None),
|
||||
("xxx", None),
|
||||
("xxx.", None),
|
||||
("xxx.yyy", None),
|
||||
("core.concept.ConceptParts.BODY", ConceptParts.BODY),
|
||||
])
|
||||
def test_i_can_decode_enum(text, expected):
|
||||
actual = core.utils.decode_enum(text)
|
||||
assert actual == expected
|
||||
|
||||
|
||||
def get_tokens(lst):
|
||||
res = []
|
||||
for e in lst:
|
||||
|
||||
Reference in New Issue
Block a user