Implemented some enhancement request and fixed some bugs
Fixed #2 : Variables are not recognized when inside a rule token Fixed #15 : Rule: rete attributes are lost when a new ontology is created Fixed #14 : ReteNetwork: Format rules must not be added to Rete network Fixed #16 : DefConcept: Variables are not recognized when they are keyword arguments Fixed #4 : Comparison are not correctly set when comparison property is a concept Fixed #14 : Parser: merge FunctionParser.NamesNode and ExpressionParser.NamesNode Fixed #18 : Parser: Add SourceCodeNode test to UnrecognizedNodeParser Fixed #20 : At startup Number concept is saved in db a numerous number of time Fixed #21 : CacheManager: I can remove all elements from a ListIfNeededCache and fill it again Fixed #22 : CacheManager: I can remove all elements from a SetCache and fill it again Fixed #23 : HistoryManager: history() no longer works Fixed #24 : HistoryManager: history() no longer works after creating an exec rule Fixed #25 : SheerkaMemory: Use MemoryObject instead of sheerka.local Fixed #26 : Debugger: add the list all available services.. Fixed #27 : CONCEPTS_GRAMMARS_ENTRY does not seems to be in use any more Fixed #28 : Give order to services
This commit is contained in:
+9
-2
@@ -104,8 +104,12 @@ class BaseTest:
|
||||
def get_sheerka(self, **kwargs) -> Sheerka:
|
||||
pass
|
||||
|
||||
def get_context(self, sheerka=None, eval_body=False, eval_where=False):
|
||||
context = ExecutionContext("test", Event(), sheerka or self.get_sheerka(), BuiltinConcepts.TESTING, None)
|
||||
def get_context(self, sheerka=None, eval_body=False, eval_where=False, message=""):
|
||||
context = ExecutionContext("test",
|
||||
Event(message=message),
|
||||
sheerka or self.get_sheerka(),
|
||||
BuiltinConcepts.TESTING,
|
||||
None)
|
||||
if eval_body:
|
||||
context.protected_hints.add(BuiltinConcepts.EVAL_BODY_REQUESTED)
|
||||
if eval_where:
|
||||
@@ -158,6 +162,9 @@ class BaseTest:
|
||||
def init_format_rules(self, *rules, **kwargs):
|
||||
return self.init_test(**kwargs).with_format_rules(*rules, **kwargs).unpack()
|
||||
|
||||
def init_exec_rules(self, *rules, **kwargs):
|
||||
return self.init_test(**kwargs).with_exec_rules(*rules, **kwargs).unpack()
|
||||
|
||||
@staticmethod
|
||||
def get_concept_instance(sheerka, concept, **kwargs):
|
||||
"""
|
||||
|
||||
@@ -15,6 +15,10 @@ class TestUsingMemoryBasedSheerka(BaseTest):
|
||||
while TestUsingMemoryBasedSheerka.sheerka.om.current_ontology().name != self.root_ontology_name:
|
||||
TestUsingMemoryBasedSheerka.sheerka.pop_ontology(self.context)
|
||||
|
||||
for service_name, service in TestUsingMemoryBasedSheerka.sheerka.services.items():
|
||||
if hasattr(service, "reset_state"):
|
||||
service.reset_state()
|
||||
|
||||
@staticmethod
|
||||
def new_sheerka_instance(cache_only):
|
||||
sheerka = Sheerka(cache_only=cache_only)
|
||||
|
||||
+83
-4
@@ -418,7 +418,22 @@ class TestListIfNeededCache(TestUsingMemoryBasedSheerka):
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_cache_remaining_values(self):
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_cache_and_then_put_back(self):
|
||||
# There is a value in alt_cache_manager,
|
||||
# No remaining value in current cache after deletion
|
||||
# The key must be flagged as Removed
|
||||
cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
|
||||
cache.put("key", "value")
|
||||
|
||||
alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True)
|
||||
cache.delete("key", value="value", alt_sdp=alt_sdp) # remove all values
|
||||
cache.put("key", "value")
|
||||
|
||||
assert cache.copy() == {"key": "value"}
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_cache_remaining_one_value(self):
|
||||
# There is a value in alt_cache_manager,
|
||||
# But this, there are remaining values in current cache after deletion
|
||||
cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
|
||||
@@ -431,11 +446,26 @@ class TestListIfNeededCache(TestUsingMemoryBasedSheerka):
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_cache_remaining_values(self):
|
||||
# There is a value in alt_cache_manager,
|
||||
# But this, there are remaining values in current cache after deletion
|
||||
cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
|
||||
cache.put("key", "value")
|
||||
cache.put("key", "value2")
|
||||
cache.put("key", "value3")
|
||||
|
||||
alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True)
|
||||
cache.delete("key", value="value", alt_sdp=alt_sdp)
|
||||
assert cache.copy() == {"key": ['value2', 'value3']}
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_key_from_remote_repository(self):
|
||||
# There is a value in alt_cache_manager,
|
||||
# No remaining value in current cache after deletion
|
||||
# The key must be flagged as Removed
|
||||
cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: ["value1", "value2"])).auto_configure("cache_name")
|
||||
cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: ["value1", "value2"])).auto_configure(
|
||||
"cache_name")
|
||||
|
||||
alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True)
|
||||
cache.delete("key", value=None, alt_sdp=alt_sdp)
|
||||
@@ -455,10 +485,23 @@ class TestListIfNeededCache(TestUsingMemoryBasedSheerka):
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_remote_repository_remaining_values(self):
|
||||
def test_i_can_delete_when_alt_sdp_a_key_from_remote_repository_and_then_put_back(self):
|
||||
cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: ["value1", "value2"])).auto_configure(
|
||||
"cache_name")
|
||||
|
||||
alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True)
|
||||
cache.delete("key", value=None, alt_sdp=alt_sdp) # remove all values
|
||||
cache.put("key", "value")
|
||||
|
||||
assert cache.copy() == {"key": "value"}
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_remote_repository_remaining_one_value(self):
|
||||
# There is a value in alt_cache_manager,
|
||||
# But this, there are remaining values in current cache after deletion
|
||||
cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: ["value1", "value2"])).auto_configure("cache_name")
|
||||
cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: ["value1", "value2"])).auto_configure(
|
||||
"cache_name")
|
||||
|
||||
alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True)
|
||||
cache.delete("key", value="value1", alt_sdp=alt_sdp)
|
||||
@@ -492,6 +535,21 @@ class TestListIfNeededCache(TestUsingMemoryBasedSheerka):
|
||||
assert cache.to_add == {"key"}
|
||||
assert cache.to_remove == set()
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_alt_sdp_and_then_put_back(self):
|
||||
# alt_cache_manager is used because no value in cache or in remote repository
|
||||
# After value deletion, the key is empty
|
||||
cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
|
||||
|
||||
alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "value1",
|
||||
extend_exists=lambda cache_name, key: True)
|
||||
|
||||
cache.delete("key", value="value1", alt_sdp=alt_sdp)
|
||||
cache.put("key", "value")
|
||||
|
||||
assert cache.copy() == {"key": "value"}
|
||||
assert cache.to_add == {"key"}
|
||||
assert cache.to_remove == set()
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_alt_sdp_one_value_remaining(self):
|
||||
# alt_cache_manager is used because no value in cache or in remote repository
|
||||
# After value deletion, one value remains in the cache
|
||||
@@ -567,3 +625,24 @@ class TestListIfNeededCache(TestUsingMemoryBasedSheerka):
|
||||
assert cache.copy() == {}
|
||||
assert cache.to_add == set()
|
||||
assert cache.to_remove == set()
|
||||
|
||||
def test_i_can_add_when_alt_sdp_from_a_removed_remote_repository(self):
|
||||
cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: Removed)).auto_configure("cache_name")
|
||||
cache.put("key", "value")
|
||||
|
||||
assert cache.copy() == {"key": "value"}
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
def test_i_can_add_when_alt_sdp_from_a_removed_remote_repository_from_alt_sdp(self):
|
||||
# The key is removed in the sub layers
|
||||
# We can put it back
|
||||
cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
|
||||
alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: Removed,
|
||||
extend_exists=lambda cache_name, key: False)
|
||||
|
||||
cache.put("key", "value", alt_sdp=alt_sdp)
|
||||
|
||||
assert cache.copy() == {"key": "value"}
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
Vendored
+63
@@ -337,6 +337,20 @@ class TestSetCache(TestUsingMemoryBasedSheerka):
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_cache_and_then_put_back(self):
|
||||
# There is a value in alt_cache_manager,
|
||||
# No remaining value in current cache after deletion
|
||||
cache = SetCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
|
||||
cache.put("key", "value")
|
||||
|
||||
alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True)
|
||||
cache.delete("key", value="value", alt_sdp=alt_sdp)
|
||||
cache.put("key", "value")
|
||||
|
||||
assert cache.copy() == {"key": {"value"}}
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_cache_remaining_values(self):
|
||||
# There is a value in alt_cache_manager,
|
||||
# But there is a value in the current cache after deletion
|
||||
@@ -371,6 +385,19 @@ class TestSetCache(TestUsingMemoryBasedSheerka):
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_remote_repository_and_then_put_back(self):
|
||||
# There is a value in alt_cache_manager,
|
||||
# No remaining value in current cache after deletion
|
||||
# The key must be flagged as Removed
|
||||
cache = SetCache(sdp=FakeSdp(get_value=lambda entry, k: {"value1", "value2"})).auto_configure("cache_name")
|
||||
|
||||
cache.delete("key", value=None, alt_sdp=FakeSdp(extend_exists=lambda cache_name, key: True))
|
||||
cache.put("key", "value")
|
||||
|
||||
assert cache.copy() == {"key": {"value"}}
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_remote_repository_remaining_values(self):
|
||||
# There is a value in alt_cache_manager,
|
||||
# But there is a value in the current cache after deletion
|
||||
@@ -407,6 +434,21 @@ class TestSetCache(TestUsingMemoryBasedSheerka):
|
||||
assert cache.to_add == {"key"}
|
||||
assert cache.to_remove == set()
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_alt_sdp_and_then_put_back(self):
|
||||
# alt_cache_manager is used because no value in cache or in remote repository
|
||||
# After value deletion, the key is empty
|
||||
cache = SetCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
|
||||
|
||||
alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: {"value1"},
|
||||
extend_exists=lambda cache_name, key: True)
|
||||
|
||||
cache.delete("key", value="value1", alt_sdp=alt_sdp)
|
||||
cache.put("key", "value")
|
||||
|
||||
assert cache.copy() == {"key": {"value"}}
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
def test_i_can_delete_when_alt_sdp_a_value_from_alt_sdp_one_value_remaining(self):
|
||||
# alt_cache_manager is used because no value in cache or in remote repository
|
||||
# After value deletion, the key is empty
|
||||
@@ -475,3 +517,24 @@ class TestSetCache(TestUsingMemoryBasedSheerka):
|
||||
assert cache.copy() == {}
|
||||
assert cache.to_add == set()
|
||||
assert cache.to_remove == set()
|
||||
|
||||
def test_i_can_add_when_alt_sdp_from_a_removed_remote_repository(self):
|
||||
cache = SetCache(sdp=FakeSdp(get_value=lambda entry, k: Removed)).auto_configure("cache_name")
|
||||
cache.put("key", "value")
|
||||
|
||||
assert cache.copy() == {"key": {"value"}}
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
def test_i_can_add_when_alt_sdp_from_a_removed_remote_repository_from_alt_sdp(self):
|
||||
# The key is removed in the sub layers
|
||||
# We can put it back
|
||||
cache = SetCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
|
||||
alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: Removed,
|
||||
extend_exists=lambda cache_name, key: False)
|
||||
|
||||
cache.put("key", "value", alt_sdp=alt_sdp)
|
||||
|
||||
assert cache.copy() == {"key": {"value"}}
|
||||
assert cache.to_remove == set()
|
||||
assert cache.to_add == {"key"}
|
||||
|
||||
@@ -3,7 +3,7 @@ import pytest
|
||||
from core.builtin_concepts import BuiltinConcepts
|
||||
from core.concept import Concept
|
||||
from core.global_symbols import EVENT_CONCEPT_PRECEDENCE_MODIFIED, CONCEPT_COMPARISON_CONTEXT, \
|
||||
EVENT_RULE_PRECEDENCE_MODIFIED, RULE_COMPARISON_CONTEXT
|
||||
EVENT_RULE_PRECEDENCE_MODIFIED, RULE_COMPARISON_CONTEXT, NotFound
|
||||
from core.sheerka.services.SheerkaComparisonManager import SheerkaComparisonManager, ComparisonObj
|
||||
from core.sheerka.services.SheerkaConceptManager import ChickenAndEggError
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
@@ -367,8 +367,8 @@ class TestSheerkaGreaterThanManager(TestUsingMemoryBasedSheerka):
|
||||
sheerka.set_is_less_than(context, "prop_name", less_l, lesser)
|
||||
sheerka.set_is_greater_than(context, "prop_name", less_l, even_more_l)
|
||||
assert service.get_weights("prop_name") == {"c:lesser|1001:": 0,
|
||||
"c:less_l|1002:": -1,
|
||||
"c:even_less_l|1003:": -2}
|
||||
"c:less_l|1002:": -1,
|
||||
"c:even_less_l|1003:": -2}
|
||||
|
||||
def test_i_cannot_define_less_than_a_lesser_if_not_a_lesser_itself(self):
|
||||
"""
|
||||
@@ -438,8 +438,8 @@ class TestSheerkaGreaterThanManager(TestUsingMemoryBasedSheerka):
|
||||
sheerka.set_is_less_than(context, "prop_name", greatest, more_g)
|
||||
sheerka.set_is_greater_than(context, "prop_name", even_more_g, more_g)
|
||||
assert service.get_weights("prop_name") == {"c:greatest|1001:": 2,
|
||||
"c:more_g|1002:": 3,
|
||||
"c:even_more_g|1003:": 4}
|
||||
"c:more_g|1002:": 3,
|
||||
"c:even_more_g|1003:": 4}
|
||||
|
||||
def test_i_can_mix_all_comparisons(self):
|
||||
sheerka, context, one, two, three, four, five, six, three_and_half = self.init_concepts(
|
||||
@@ -657,7 +657,7 @@ class TestSheerkaGreaterThanManager(TestUsingMemoryBasedSheerka):
|
||||
(["a = z", "z>>", "b<c", "c<d"], {"a": 4, "b": 1, "c": 2, "d": 3, "z": 4}),
|
||||
(["b = a", "c = b", "a > d"], {"a": 2, "b": 2, "c": 2, "d": 1}),
|
||||
(["a = b", "b = c", "a > d"], {"a": 2, "b": 2, "c": 2, "d": 1}),
|
||||
#(["a = b", "b = c", "c > d"], {"a": 2, "b": 2, "c": 2, "d": 1}), # not working
|
||||
# (["a = b", "b = c", "c > d"], {"a": 2, "b": 2, "c": 2, "d": 1}), # not working
|
||||
|
||||
# mix greatest and lesser
|
||||
(["a >>", "b<<", "a > b"], {"a": 2, "b": 0}),
|
||||
@@ -732,3 +732,25 @@ class TestSheerkaGreaterThanManager(TestUsingMemoryBasedSheerka):
|
||||
|
||||
assert not res.status
|
||||
assert sheerka.isinstance(res.body, BuiltinConcepts.IS_LESSER_CONSTRAINT_ERROR)
|
||||
|
||||
def test_i_can_seamlessly_use_concept_name_or_concept_itself_when_builtin_concept_to_define_comparison(self):
|
||||
sheerka, context, foo, bar, baz = self.init_concepts("foo", "bar", "baz")
|
||||
|
||||
prec_as_concept = sheerka.new(BuiltinConcepts.PRECEDENCE)
|
||||
sheerka.set_is_greater_than(context, BuiltinConcepts.PRECEDENCE, foo, bar)
|
||||
sheerka.set_is_greater_than(context, prec_as_concept, foo, baz)
|
||||
|
||||
assert sheerka.om.get(SheerkaComparisonManager.COMPARISON_ENTRY, f"{BuiltinConcepts.PRECEDENCE}|#") == [
|
||||
ComparisonObj(context.event.get_digest(), BuiltinConcepts.PRECEDENCE, foo.str_id, bar.str_id, ">", "#"),
|
||||
ComparisonObj(context.event.get_digest(), BuiltinConcepts.PRECEDENCE, foo.str_id, baz.str_id, ">", "#"),
|
||||
]
|
||||
assert sheerka.om.get(SheerkaComparisonManager.COMPARISON_ENTRY, f"{prec_as_concept.str_id}|#") is NotFound
|
||||
|
||||
def test_i_can_seamlessly_use_concept_id_or_concept_itself_to_define_comparison(self):
|
||||
sheerka, context, foo, bar, baz, op = self.init_concepts("foo", "bar", "baz", "op")
|
||||
sheerka.set_is_greater_than(context, op.str_id, foo, bar)
|
||||
sheerka.set_is_greater_than(context, op, foo, baz)
|
||||
assert sheerka.om.get(SheerkaComparisonManager.COMPARISON_ENTRY, f"{op.str_id}|#") == [
|
||||
ComparisonObj(context.event.get_digest(), op.str_id, foo.str_id, bar.str_id, ">", "#"),
|
||||
ComparisonObj(context.event.get_digest(), op.str_id, foo.str_id, baz.str_id, ">", "#"),
|
||||
]
|
||||
|
||||
@@ -884,7 +884,7 @@ class TestSheerkaConceptManager(TestUsingMemoryBasedSheerka):
|
||||
sheerka.set_isa(context, sheerka.new("twenties"), number)
|
||||
sheerka.set_isa(context, sheerka.new("hundreds"), number)
|
||||
|
||||
sheerka.concepts_grammars.clear() # reset all the grammar to simulate Sheerka restart
|
||||
sheerka.clear_bnf_definition() # reset all the grammar to simulate Sheerka restart
|
||||
|
||||
# cbft : concept_by_first_token (I usually don't use abbreviation)
|
||||
cbft = compute_concepts_by_first_token(context, [number] + concepts).body
|
||||
|
||||
@@ -19,14 +19,32 @@ class DummyObj:
|
||||
|
||||
|
||||
class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
|
||||
|
||||
return_value_id = 0
|
||||
rv = None
|
||||
rr = None
|
||||
rc = None
|
||||
|
||||
@classmethod
|
||||
def setup(cls):
|
||||
sheerka = cls().get_sheerka()
|
||||
cls.return_value_id = sheerka.get_by_key("__RETURN_VALUE").id
|
||||
|
||||
def backup_registered(self, service):
|
||||
self.rv = service.registered_vars.copy(),
|
||||
self.rr = service.registered_rules.copy(),
|
||||
self.rc = service.registered_concepts.copy(),
|
||||
service.registered_vars.clear()
|
||||
service.registered_rules.clear()
|
||||
service.registered_concepts.clear()
|
||||
|
||||
def restore_registered(self, service):
|
||||
service.registered_vars.clear()
|
||||
service.registered_rules.clear()
|
||||
service.registered_concepts.clear()
|
||||
service.registered_vars.extend(self.rv)
|
||||
service.registered_vars.extend(self.rr)
|
||||
service.registered_vars.extend(self.rc)
|
||||
|
||||
@pytest.mark.parametrize("item_type", [
|
||||
"vars", "rules", "concepts"
|
||||
])
|
||||
@@ -387,7 +405,7 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
|
||||
sheerka, context = self.init_concepts()
|
||||
service = sheerka.services[SheerkaDebugManager.NAME]
|
||||
|
||||
sheerka.debug_var(context, "s.m.v", "1+", 10, variable="my_var")
|
||||
sheerka.set_debug_var(context, "s.m.v", "1+", 10, variable="my_var")
|
||||
assert service.debug_vars_settings == [
|
||||
DebugItem("my_var", "s", "m", 1, True, 10, False, True)
|
||||
]
|
||||
@@ -398,7 +416,7 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
|
||||
sheerka, context = self.init_concepts()
|
||||
service = sheerka.services[SheerkaDebugManager.NAME]
|
||||
|
||||
sheerka.debug_rule(context, "s.m.v", "1+", 10, rule="my_rule")
|
||||
sheerka.set_debug_rule(context, "s.m.v", "1+", 10, rule="my_rule")
|
||||
assert service.debug_rules_settings == [
|
||||
DebugItem("my_rule", "s", "m", 1, True, 10, False, True)
|
||||
]
|
||||
@@ -409,7 +427,7 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
|
||||
sheerka, context = self.init_concepts()
|
||||
service = sheerka.services[SheerkaDebugManager.NAME]
|
||||
|
||||
sheerka.debug_concept(context, "s.m.v", "1+", 10, concept="my_concept")
|
||||
sheerka.set_debug_concept(context, "s.m.v", "1+", 10, concept="my_concept")
|
||||
assert service.debug_concepts_settings == [
|
||||
DebugItem("my_concept", "s", "m", 1, True, 10, False, True)
|
||||
]
|
||||
@@ -422,9 +440,9 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
|
||||
root_context = self.get_context(sheerka)
|
||||
|
||||
sheerka.set_debug(root_context, True)
|
||||
sheerka.debug_var(root_context, "service_name.*.var")
|
||||
sheerka.debug_rule(root_context, 1)
|
||||
sheerka.debug_concept(root_context, 1001)
|
||||
sheerka.set_debug_var(root_context, "service_name.*.var")
|
||||
sheerka.set_debug_rule(root_context, 1)
|
||||
sheerka.set_debug_concept(root_context, 1001)
|
||||
|
||||
another_service = SheerkaDebugManager(sheerka)
|
||||
another_service.initialize_deferred(root_context, True)
|
||||
@@ -705,9 +723,9 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
|
||||
sheerka.push_ontology(context, "new ontology")
|
||||
|
||||
service.set_debug(context)
|
||||
service.debug_var(context, "var_service.var_method.var_name", "1+", 1)
|
||||
service.debug_rule(context, "rule_service.rule_method.rule_name", "2+", 2)
|
||||
service.debug_concept(context, "concept_service.concept_method.concept_name", "3+", 3)
|
||||
service.set_debug_var(context, "var_service.var_method.var_name", "1+", 1)
|
||||
service.set_debug_rule(context, "rule_service.rule_method.rule_name", "2+", 2)
|
||||
service.set_debug_concept(context, "concept_service.concept_method.concept_name", "3+", 3)
|
||||
|
||||
# sanity check
|
||||
assert service.activated
|
||||
@@ -728,17 +746,17 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
|
||||
service = sheerka.services[SheerkaDebugManager.NAME]
|
||||
|
||||
service.set_debug(context)
|
||||
service.debug_var(context, "v_service.v_method.v_name", "1+", 1)
|
||||
service.debug_rule(context, "r_service.r_method.r_name", "2+", 2)
|
||||
service.debug_concept(context, "c_serv.c_method.c_name", "3+", 3)
|
||||
service.set_debug_var(context, "v_service.v_method.v_name", "1+", 1)
|
||||
service.set_debug_rule(context, "r_service.r_method.r_name", "2+", 2)
|
||||
service.set_debug_concept(context, "c_serv.c_method.c_name", "3+", 3)
|
||||
|
||||
sheerka.push_ontology(context, "new ontology")
|
||||
|
||||
# modify the state
|
||||
service.set_debug(context, False)
|
||||
service.debug_var(context, "var_service2.var_method2.var_name2", "11+", 11)
|
||||
service.debug_rule(context, "rule_service2.rule_method2.rule_name2", "22+", 22)
|
||||
service.debug_concept(context, "concept_service2.concept_method2.concept_name2", "33+", 33)
|
||||
service.set_debug_var(context, "var_service2.var_method2.var_name2", "11+", 11)
|
||||
service.set_debug_rule(context, "rule_service2.rule_method2.rule_name2", "22+", 22)
|
||||
service.set_debug_concept(context, "concept_service2.concept_method2.concept_name2", "33+", 33)
|
||||
|
||||
# sanity
|
||||
assert not service.activated
|
||||
@@ -752,3 +770,133 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
|
||||
assert service.debug_vars_settings == [DebugItem("v_name", "v_service", "v_method", 1, True, 1, False, True)]
|
||||
assert service.debug_rules_settings == [DebugItem("r_name", "r_service", "r_method", 2, True, 2, False, True)]
|
||||
assert service.debug_concepts_settings == [DebugItem("c_name", "c_serv", "c_method", 3, True, 3, False, True)]
|
||||
|
||||
def test_i_can_register_debug_item(self):
|
||||
sheerka, context = self.init_concepts()
|
||||
service = sheerka.services[SheerkaDebugManager.NAME]
|
||||
|
||||
try:
|
||||
self.backup_registered(service)
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service", "method", "var_name")
|
||||
assert service.registered_vars == [("service", "method", "var_name")]
|
||||
|
||||
service.register_debug(service.RULES_DEBUG_TYPE, "service", "method", "rule_name")
|
||||
assert service.registered_rules == [("service", "method", "rule_name")]
|
||||
|
||||
service.register_debug(service.CONCEPTS_DEBUG_TYPE, "service", "method", "concept_name")
|
||||
assert service.registered_concepts == [("service", "method", "concept_name")]
|
||||
finally:
|
||||
self.restore_registered(service)
|
||||
|
||||
def test_i_can_filter_registered_debug_item(self):
|
||||
sheerka, context = self.init_concepts()
|
||||
service = sheerka.services[SheerkaDebugManager.NAME]
|
||||
|
||||
try:
|
||||
self.backup_registered(service)
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service1", "method1", "var_name1")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service1", "method1", "var_name2")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service1", "method2", "var_name1")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service1", "method2", "var_name2")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service2", "method1", "var_name1")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service2", "method1", "var_name2")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service2", "method2", "var_name1")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service2", "method2", "var_name2")
|
||||
|
||||
assert list(service.filter_registered_debug(service.VARS_DEBUG_TYPE, "service1")) == [
|
||||
("service1", "method1", "var_name1"),
|
||||
("service1", "method1", "var_name2"),
|
||||
("service1", "method2", "var_name1"),
|
||||
("service1", "method2", "var_name2"),
|
||||
]
|
||||
|
||||
assert list(service.filter_registered_debug(service.VARS_DEBUG_TYPE, "service1.method2")) == [
|
||||
("service1", "method2", "var_name1"),
|
||||
("service1", "method2", "var_name2"),
|
||||
]
|
||||
|
||||
assert list(service.filter_registered_debug(service.VARS_DEBUG_TYPE, "service1.method2.var_name1")) == [
|
||||
("service1", "method2", "var_name1"),
|
||||
]
|
||||
|
||||
assert list(service.filter_registered_debug(service.VARS_DEBUG_TYPE, "*.*.var_name1")) == [
|
||||
("service1", "method1", "var_name1"),
|
||||
("service1", "method2", "var_name1"),
|
||||
("service2", "method1", "var_name1"),
|
||||
("service2", "method2", "var_name1"),
|
||||
]
|
||||
|
||||
assert list(service.filter_registered_debug(service.VARS_DEBUG_TYPE, "*.method2.*")) == [
|
||||
("service1", "method2", "var_name1"),
|
||||
("service1", "method2", "var_name2"),
|
||||
("service2", "method2", "var_name1"),
|
||||
("service2", "method2", "var_name2"),
|
||||
]
|
||||
|
||||
assert list(service.filter_registered_debug(service.VARS_DEBUG_TYPE, method="method1")) == [
|
||||
("service1", "method1", "var_name1"),
|
||||
("service1", "method1", "var_name2"),
|
||||
("service2", "method1", "var_name1"),
|
||||
("service2", "method1", "var_name2"),
|
||||
]
|
||||
finally:
|
||||
self.restore_registered(service)
|
||||
|
||||
def test_i_can_list_registered_debug(self):
|
||||
sheerka, context = self.init_concepts()
|
||||
service = sheerka.services[SheerkaDebugManager.NAME]
|
||||
|
||||
try:
|
||||
self.backup_registered(service)
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service1", "method1", "var_name1")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service1", "method1", "var_name2")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service1", "method2", "var_name3")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service1", "method2", "var_name4")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service2", "method3", "var_name5")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service2", "method3", "var_name6")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service2", "method1", "var_name7")
|
||||
service.register_debug(service.VARS_DEBUG_TYPE, "service2", "method1", "var_name8")
|
||||
|
||||
res = service.list_registered(service.VARS_DEBUG_TYPE)
|
||||
assert sheerka.isinstance(res, BuiltinConcepts.TO_LIST)
|
||||
assert list(res.body) == ["service1", "service2"]
|
||||
|
||||
res = service.list_registered(service.VARS_DEBUG_TYPE, "service2")
|
||||
assert sheerka.isinstance(res, BuiltinConcepts.TO_LIST)
|
||||
assert list(res.body) == ["service2.method1", "service2.method3"]
|
||||
|
||||
res = service.list_registered(service.VARS_DEBUG_TYPE, "service2.method3")
|
||||
assert sheerka.isinstance(res, BuiltinConcepts.TO_LIST)
|
||||
assert list(res.body) == ["service2.method3.var_name5", "service2.method3.var_name6"]
|
||||
|
||||
res = service.list_registered(service.VARS_DEBUG_TYPE, "*.method1")
|
||||
assert sheerka.isinstance(res, BuiltinConcepts.TO_LIST)
|
||||
assert list(res.body) == [
|
||||
"service1.method1.var_name1",
|
||||
"service1.method1.var_name2",
|
||||
"service2.method1.var_name7",
|
||||
"service2.method1.var_name8",
|
||||
]
|
||||
|
||||
res = service.list_registered(service.VARS_DEBUG_TYPE, method="method1")
|
||||
assert sheerka.isinstance(res, BuiltinConcepts.TO_LIST)
|
||||
assert list(res.body) == [
|
||||
"service1.method1.var_name1",
|
||||
"service1.method1.var_name2",
|
||||
"service2.method1.var_name7",
|
||||
"service2.method1.var_name8",
|
||||
]
|
||||
|
||||
res = service.list_registered(service.VARS_DEBUG_TYPE, "*.*.var_name7")
|
||||
assert sheerka.isinstance(res, BuiltinConcepts.TO_LIST)
|
||||
assert list(res.body) == [
|
||||
"service2.method1.var_name7",
|
||||
]
|
||||
|
||||
res = service.list_registered(service.VARS_DEBUG_TYPE, variable="var_name7")
|
||||
assert sheerka.isinstance(res, BuiltinConcepts.TO_LIST)
|
||||
assert list(res.body) == [
|
||||
"service2.method1.var_name7",
|
||||
]
|
||||
finally:
|
||||
self.restore_registered(service)
|
||||
|
||||
@@ -1,15 +1,13 @@
|
||||
from dataclasses import dataclass
|
||||
|
||||
import pytest
|
||||
|
||||
from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept, ParserResultConcept
|
||||
from core.concept import Concept, DoNotResolve, ConceptParts, InfiniteRecursionResolved, CB, \
|
||||
concept_part_value, DEFINITION_TYPE_DEF
|
||||
from core.global_symbols import NotInit
|
||||
from core.global_symbols import NotInit, NotFound
|
||||
from core.sheerka.services.SheerkaEvaluateConcept import SheerkaEvaluateConcept
|
||||
from core.sheerka.services.SheerkaMemory import SheerkaMemory
|
||||
from parsers.BaseParser import BaseParser
|
||||
from parsers.PythonParser import PythonNode, PythonParser
|
||||
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
from tests.evaluators.EvaluatorTestsUtils import pr_ret_val, python_ret_val
|
||||
|
||||
@@ -778,12 +776,12 @@ class TestSheerkaEvaluateConcept(TestUsingMemoryBasedSheerka):
|
||||
|
||||
evaluated = sheerka.evaluate_concept(context, command)
|
||||
assert evaluated.key == command.key
|
||||
assert "a" not in sheerka.locals
|
||||
assert sheerka.get_from_memory(context, "a") == NotFound
|
||||
|
||||
sheerka.set_isa(context, command, sheerka.new(BuiltinConcepts.AUTO_EVAL))
|
||||
evaluated = sheerka.evaluate_concept(context, sheerka.new("command"))
|
||||
assert evaluated.key == command.key
|
||||
assert "a" in sheerka.locals
|
||||
assert sheerka.get_from_memory(context, "a").obj == 10
|
||||
|
||||
@pytest.mark.parametrize("metadata", [
|
||||
ConceptParts.WHERE,
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
from core.sheerka.services.SheerkaHistoryManager import hist
|
||||
from core.sheerka.services.SheerkaHistoryManager import hist, SheerkaHistoryManager
|
||||
from tests.TestUsingFileBasedSheerka import TestUsingFileBasedSheerka
|
||||
|
||||
|
||||
class TestSheerkaHistoryManager(TestUsingFileBasedSheerka):
|
||||
def test_i_can_retrieve_history(self):
|
||||
sheerka = self.get_sheerka()
|
||||
service = sheerka.services[SheerkaHistoryManager.NAME]
|
||||
sheerka.save_execution_context = True
|
||||
|
||||
sheerka.evaluate_user_input("def concept one as 1")
|
||||
@@ -19,7 +20,7 @@ class TestSheerkaHistoryManager(TestUsingFileBasedSheerka):
|
||||
sheerka.evaluate_user_input("def concept five as 5")
|
||||
sheerka.evaluate_user_input("five")
|
||||
|
||||
h = list(sheerka.history(-1)) # all
|
||||
h = list(service.history(-1)) # all
|
||||
assert h == [
|
||||
hist("five", True),
|
||||
hist("def concept five as 5", True),
|
||||
@@ -35,13 +36,13 @@ class TestSheerkaHistoryManager(TestUsingFileBasedSheerka):
|
||||
hist("Initializing Sheerka.", None)
|
||||
]
|
||||
|
||||
h = list(sheerka.history(2))
|
||||
h = list(service.history(2))
|
||||
assert h == [
|
||||
hist("five", True),
|
||||
hist("def concept five as 5", True)
|
||||
]
|
||||
|
||||
h = list(sheerka.history(2, 2))
|
||||
h = list(service.history(2, 2))
|
||||
assert h == [
|
||||
hist("four", True),
|
||||
hist("def concept four as 4", True),
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
import pytest
|
||||
|
||||
from core.builtin_concepts import BuiltinConcepts
|
||||
from core.concept import Concept
|
||||
from core.sheerka.services.SheerkaIsAManager import SheerkaIsAManager
|
||||
@@ -278,7 +276,7 @@ class TestSheerkaIsAManager(TestUsingMemoryBasedSheerka):
|
||||
assert [c.id for c in concepts_in_cache] == [one.id]
|
||||
|
||||
# pretend that number has been updated in sheerka.concepts_grammar
|
||||
sheerka.concepts_grammars.put(number.id, "some parsing expression with 'one' only")
|
||||
sheerka.get_concepts_bnf_definitions().put(number.id, "some parsing expression with 'one' only")
|
||||
|
||||
# add another element to number
|
||||
sheerka.set_isa(context, sheerka.new("two"), number)
|
||||
@@ -289,7 +287,7 @@ class TestSheerkaIsAManager(TestUsingMemoryBasedSheerka):
|
||||
assert {c.id for c in concepts_in_cache} == {one.id, two.id}
|
||||
|
||||
# make sure the bnf definition is also updated
|
||||
assert number.id not in sheerka.concepts_grammars
|
||||
assert number.id not in sheerka.get_concepts_bnf_definitions()
|
||||
|
||||
def test_i_can_get_and_set_isa_when_multiple_ontology_layers(self):
|
||||
sheerka, context, foo, group1, group2 = self.init_concepts(
|
||||
|
||||
@@ -88,7 +88,6 @@ class TestSheerkaMemory(TestUsingMemoryBasedSheerka):
|
||||
assert sheerka.om.copy(SheerkaMemory.OBJECTS_ENTRY) == {"a": MemoryObject(context.event.get_digest(), foo)}
|
||||
assert id(sheerka.get_from_memory(context, "a").obj) == id(foo)
|
||||
|
||||
|
||||
def test_i_can_use_memory_with_a_string(self):
|
||||
sheerka, context = self.init_test().unpack()
|
||||
|
||||
@@ -129,6 +128,69 @@ class TestSheerkaMemory(TestUsingMemoryBasedSheerka):
|
||||
|
||||
assert len(sheerka.om.get_all(SheerkaMemory.OBJECTS_ENTRY)) == 0
|
||||
|
||||
def test_adding_the_same_object_with_same_context_has_no_effect_when_one_element(self):
|
||||
sheerka, context, foo = self.init_concepts("foo")
|
||||
service = sheerka.services[SheerkaMemory.NAME]
|
||||
|
||||
sheerka.add_to_memory(context, "item", foo)
|
||||
from_memory = service.get_from_memory(context, "item")
|
||||
|
||||
sheerka.add_to_memory(context, "item", foo)
|
||||
from_memory_again = service.get_from_memory(context, "item")
|
||||
assert from_memory_again == from_memory
|
||||
|
||||
def test_adding_the_same_object_with_same_context_has_no_effect_when_multiple_elements(self):
|
||||
sheerka, context, foo, bar, baz = self.init_concepts("foo", "bar", "baz")
|
||||
service = sheerka.services[SheerkaMemory.NAME]
|
||||
|
||||
sheerka.add_to_memory(context, "item", foo)
|
||||
sheerka.add_to_memory(context, "item", bar)
|
||||
sheerka.add_to_memory(context, "item", baz)
|
||||
from_memory = service.get_from_memory(context, "item").copy()
|
||||
|
||||
sheerka.add_to_memory(context, "item", baz)
|
||||
from_memory_again = service.get_from_memory(context, "item")
|
||||
assert from_memory_again == from_memory
|
||||
|
||||
def test_adding_the_same_object_with_a_different_context_updates_event_id_when_one_element(self):
|
||||
sheerka, context1, foo = self.init_concepts("foo")
|
||||
service = sheerka.services[SheerkaMemory.NAME]
|
||||
|
||||
sheerka.add_to_memory(context1, "item", foo)
|
||||
from_memory = service.get_from_memory(context1, "item")
|
||||
|
||||
context2 = self.get_context(self.sheerka, message="another message")
|
||||
sheerka.add_to_memory(context2, "item", foo)
|
||||
from_memory_again = service.get_from_memory(context2, "item")
|
||||
|
||||
assert from_memory_again != from_memory
|
||||
assert not isinstance(from_memory_again, list)
|
||||
|
||||
assert from_memory_again.obj == from_memory.obj
|
||||
assert from_memory_again.event_id == context2.event.get_digest()
|
||||
assert from_memory.event_id == context1.event.get_digest()
|
||||
|
||||
def test_adding_the_same_object_with_a_different_context_updates_event_id_when_multiple_elements(self):
|
||||
sheerka, context, foo, bar, baz = self.init_concepts("foo", "bar", "baz")
|
||||
service = sheerka.services[SheerkaMemory.NAME]
|
||||
|
||||
sheerka.add_to_memory(context, "item", foo)
|
||||
sheerka.add_to_memory(context, "item", bar)
|
||||
sheerka.add_to_memory(context, "item", baz)
|
||||
from_memory = service.get_from_memory(context, "item").copy()
|
||||
|
||||
context2 = self.get_context(self.sheerka, message="another message")
|
||||
sheerka.add_to_memory(context2, "item", baz)
|
||||
from_memory_again = service.get_from_memory(context2, "item")
|
||||
|
||||
assert isinstance(from_memory_again, list)
|
||||
assert len(from_memory) == len(from_memory_again)
|
||||
for mo, mo_again in zip(from_memory, from_memory_again[:-1]):
|
||||
assert mo == mo_again
|
||||
|
||||
assert from_memory[-1].obj == from_memory_again[-1].obj
|
||||
assert from_memory[-1].event_id != from_memory_again[-1].event_id
|
||||
|
||||
|
||||
class TestSheerkaMemoryUsingFileBase(TestUsingFileBasedSheerka):
|
||||
def test_i_can_record_memory_objects(self):
|
||||
|
||||
@@ -991,6 +991,18 @@ isinstance(var, Concept) and var.key == 'hello __var__0'""" + \
|
||||
assert isinstance(res[0], AndConditions)
|
||||
assert res[0].conditions == [Condition(V("__x_00__"), "__name__", "__ret")]
|
||||
|
||||
def test_i_can_properly_copy_a_rule(self):
|
||||
sheerka, context = self.init_test().unpack()
|
||||
service = sheerka.services[SheerkaRuleManager.NAME]
|
||||
|
||||
rule = Rule(ACTION_TYPE_EXEC, "name", "id.attr == 'value'", 'test()')
|
||||
service.init_rule(context, rule)
|
||||
service.create_new_rule(context, rule)
|
||||
|
||||
clone = rule.__deepcopy__({})
|
||||
for k, v in vars(rule).items():
|
||||
assert getattr(clone, k) == getattr(rule, k)
|
||||
|
||||
|
||||
class TestSheerkaRuleManagerUsingFileBasedSheerka(TestUsingFileBasedSheerka):
|
||||
def test_rules_are_initialized_at_startup(self):
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
import ast
|
||||
|
||||
import pytest
|
||||
from core.ast_helpers import UnreferencedNamesVisitor, UnreferencedVariablesVisitor
|
||||
|
||||
from core.ast_helpers import UnreferencedNamesVisitor, UnreferencedVariablesVisitor
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
|
||||
@@ -13,7 +13,8 @@ class TestAstHelper(TestUsingMemoryBasedSheerka):
|
||||
("date.today()", {"date"}),
|
||||
("test()", {"test"}),
|
||||
("sheerka.test()", {"sheerka"}),
|
||||
("for i in range(10): pass", set())
|
||||
("for i in range(10): pass", set()),
|
||||
("func(x=a, y=b)", {"func", "a", "b"}),
|
||||
|
||||
])
|
||||
def test_i_can_get_unreferenced_names_from_simple_expressions(self, source, expected):
|
||||
@@ -31,8 +32,8 @@ class TestAstHelper(TestUsingMemoryBasedSheerka):
|
||||
("date.today()", set()),
|
||||
("test()", set()),
|
||||
("sheerka.test()", set()),
|
||||
("for i in range(10): pass", set())
|
||||
|
||||
("for i in range(10): pass", set()),
|
||||
("func(x=a, y=b)", {"a", "b", "x", "y"}),
|
||||
])
|
||||
def test_i_can_get_unreferenced_variables_from_simple_expressions(self, source, expected):
|
||||
context = self.get_context()
|
||||
|
||||
@@ -8,10 +8,8 @@ from core.builtin_concepts_ids import AllBuiltinConcepts
|
||||
from core.concept import Concept, PROPERTIES_TO_SERIALIZE, ConceptParts, get_concept_attrs
|
||||
from core.global_symbols import NotInit
|
||||
from core.sheerka.Sheerka import Sheerka, BASE_NODE_PARSER_CLASS
|
||||
from core.sheerka.SheerkaOntologyManager import OntologyAlreadyExists
|
||||
from core.sheerka.services.SheerkaConceptManager import SheerkaConceptManager
|
||||
from core.tokenizer import Token, TokenKind
|
||||
|
||||
from tests.TestUsingFileBasedSheerka import TestUsingFileBasedSheerka
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
@@ -370,12 +368,10 @@ class TestSheerkaUsingMemoryBasedSheerka(TestUsingMemoryBasedSheerka):
|
||||
assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)
|
||||
|
||||
foo = sheerka.create_new_concept(context, Concept("foo").def_var("a").def_var("b")).body.body
|
||||
sheerka.locals = {"key1": "value1"}
|
||||
|
||||
# sanity check
|
||||
assert sheerka.get_by_name("foo") == foo
|
||||
assert not sheerka.is_known(sheerka.get_by_name("bar"))
|
||||
assert sheerka.locals == {"key1": "value1"}
|
||||
assert get_concept_attrs(foo) == ["a", "b"]
|
||||
|
||||
# record the ontology
|
||||
@@ -386,12 +382,10 @@ class TestSheerkaUsingMemoryBasedSheerka(TestUsingMemoryBasedSheerka):
|
||||
sheerka.push_ontology(context, "another ontology")
|
||||
foo2 = sheerka.create_new_concept(context, Concept("foo").def_var("a").def_var("b").def_var("c")).body.body
|
||||
bar = sheerka.create_new_concept(context, Concept("bar")).body.body
|
||||
sheerka.locals = {"key2": "value2"}
|
||||
|
||||
# sanity check
|
||||
assert sheerka.get_by_name("foo") == foo2
|
||||
assert sheerka.get_by_name("bar") == bar
|
||||
assert sheerka.locals == {"key2": "value2"}
|
||||
assert get_concept_attrs(foo) == ["a", "b", "c"]
|
||||
|
||||
# put pack the previous ontology
|
||||
@@ -399,14 +393,12 @@ class TestSheerkaUsingMemoryBasedSheerka(TestUsingMemoryBasedSheerka):
|
||||
|
||||
assert sheerka.get_by_name("foo") == foo # not [foo, foo2], foo2 is not seen !!!
|
||||
assert sheerka.get_by_name("bar") == bar
|
||||
assert sheerka.locals == {"key1": "value1"}
|
||||
assert get_concept_attrs(foo) == ["a", "b"]
|
||||
|
||||
# sanity check
|
||||
sheerka.pop_ontology(context)
|
||||
assert sheerka.get_by_name("foo") == foo2
|
||||
assert sheerka.get_by_name("bar") == bar
|
||||
assert sheerka.locals == {"key2": "value2"}
|
||||
assert get_concept_attrs(foo) == ["a", "b", "c"]
|
||||
|
||||
def test_adding_the_same_ontology_twice_has_no_effect(self):
|
||||
|
||||
@@ -151,7 +151,8 @@ class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
|
||||
service = SheerkaExecute(sheerka)
|
||||
service.reset_registered_parsers()
|
||||
|
||||
groups, sorted_priorities = service.get_parsers(context)
|
||||
parsers_key, groups, sorted_priorities = service.get_parsers(context)
|
||||
assert parsers_key == "__default"
|
||||
assert groups == {80: [Enabled80FalseParser()], 90: [Enabled90FalseParser()]}
|
||||
assert sorted_priorities == [90, 80]
|
||||
|
||||
@@ -169,7 +170,8 @@ class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
|
||||
parsers_names = ["Enabled50True", "Enabled70False", "Disabled"]
|
||||
context.preprocess_parsers = parsers_names
|
||||
|
||||
groups, sorted_priorities = service.get_parsers(context)
|
||||
parsers_key, groups, sorted_priorities = service.get_parsers(context)
|
||||
assert parsers_key == "Enabled50True|Enabled70False|Disabled"
|
||||
assert groups == {50: [Enabled50TrueParser()], 70: [Enabled70FalseParser()]}
|
||||
assert sorted_priorities == [70, 50] # Disabled parser does not appear
|
||||
|
||||
@@ -195,7 +197,8 @@ class TestSheerkaExecuteParsers(TestUsingMemoryBasedSheerka):
|
||||
context.add_preprocess(BaseParser.get_name("Enabled90False"), enabled=False)
|
||||
context.add_preprocess(BaseParser.get_name("Enabled50True"), priority=80)
|
||||
|
||||
groups, sorted_priorities = service.get_parsers(context)
|
||||
parsers_key, groups, sorted_priorities = service.get_parsers(context)
|
||||
assert parsers_key is None
|
||||
assert groups == {80: [Enabled50TrueParser()], 70: [Enabled70FalseParser()]}
|
||||
assert sorted_priorities == [80, 70] # Disabled parsers does not appear
|
||||
|
||||
|
||||
@@ -1,16 +1,17 @@
|
||||
import ast
|
||||
|
||||
import pytest
|
||||
|
||||
from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
|
||||
from core.concept import VARIABLE_PREFIX, Concept, DEFINITION_TYPE_BNF, DEFINITION_TYPE_DEF
|
||||
from core.sheerka.services.SheerkaExecute import ParserInput
|
||||
from core.tokenizer import Tokenizer
|
||||
from evaluators.DefConceptEvaluator import DefConceptEvaluator
|
||||
from parsers.BaseParser import BaseParser
|
||||
from parsers.BnfDefinitionParser import BnfDefinitionParser
|
||||
from parsers.BnfNodeParser import Sequence, StrMatch, ZeroOrMore, ConceptExpression
|
||||
from parsers.DefConceptParser import DefConceptNode, NameNode
|
||||
from parsers.DefConceptParser import DefConceptNode, NameNode, DefConceptParser
|
||||
from parsers.PythonParser import PythonNode, PythonParser
|
||||
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
|
||||
@@ -244,3 +245,35 @@ class TestDefConceptEvaluator(TestUsingMemoryBasedSheerka):
|
||||
assert new_concept.get_metadata().body == 'foo'
|
||||
assert new_concept.values() == {}
|
||||
assert new_concept.get_metadata().variables == []
|
||||
|
||||
def test_i_can_get_variable_when_rule_is_defined(self):
|
||||
sheerka, context = self.init_test().unpack()
|
||||
def_concept_parser = DefConceptParser()
|
||||
|
||||
parsed_ret_val = def_concept_parser.parse(context, ParserInput("def concept rule x as r:|x:"))
|
||||
assert parsed_ret_val.status # sanity check
|
||||
|
||||
evaluated = DefConceptEvaluator().eval(context, parsed_ret_val)
|
||||
assert evaluated.status
|
||||
assert evaluated.body.body.key == "rule __var__0"
|
||||
assert evaluated.body.body.get_metadata().variables == [("x", None)]
|
||||
|
||||
def test_i_can_recognize_variable_when_keyword_argument(self):
|
||||
sheerka, context = self.init_test().unpack()
|
||||
def_concept_parser = DefConceptParser()
|
||||
|
||||
parsed_ret_val = def_concept_parser.parse(context, ParserInput("def concept foo1 x as func(param=x)"))
|
||||
assert parsed_ret_val.status # sanity check
|
||||
|
||||
evaluated = DefConceptEvaluator().eval(context, parsed_ret_val)
|
||||
assert evaluated.status
|
||||
assert evaluated.body.body.key == "foo1 __var__0"
|
||||
assert evaluated.body.body.get_metadata().variables == [("x", None)]
|
||||
|
||||
parsed_ret_val = def_concept_parser.parse(context, ParserInput("def concept foo2 x as func(x=value)"))
|
||||
assert parsed_ret_val.status # sanity check
|
||||
|
||||
evaluated = DefConceptEvaluator().eval(context, parsed_ret_val)
|
||||
assert evaluated.status
|
||||
assert evaluated.body.body.key == "foo2 __var__0"
|
||||
assert evaluated.body.body.get_metadata().variables == [("x", None)]
|
||||
|
||||
@@ -12,7 +12,6 @@ from evaluators.PythonEvaluator import PythonEvaluator, PythonEvalError, NamesWi
|
||||
from parsers.BaseNodeParser import SourceCodeNode, SourceCodeWithConceptNode
|
||||
from parsers.FunctionParser import FunctionParser
|
||||
from parsers.PythonParser import PythonNode, PythonParser
|
||||
from parsers.PythonWithConceptsParser import PythonWithConceptsParser
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
|
||||
@@ -228,7 +227,7 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
|
||||
|
||||
assert evaluated.status
|
||||
assert sheerka.get_weights(BuiltinConcepts.PRECEDENCE) == {'c:__var__0 plus __var__1|1001:': 1,
|
||||
'c:__var__0 mult __var__1|1002:': 2}
|
||||
'c:__var__0 mult __var__1|1002:': 2}
|
||||
|
||||
def test_i_can_define_variables(self):
|
||||
sheerka, context = self.init_test().unpack()
|
||||
@@ -293,21 +292,6 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
|
||||
assert error1.error.args[0] == 'can only concatenate str (not "int") to str'
|
||||
assert error1.concepts == {'foo': 'string'}
|
||||
|
||||
def test_i_can_use_sheerka_locals(self):
|
||||
sheerka, context = self.init_test().unpack()
|
||||
|
||||
def func(i):
|
||||
return i + 1
|
||||
|
||||
sheerka.locals["func"] = func
|
||||
|
||||
parsed = PythonParser().parse(context, ParserInput("func(10)"))
|
||||
python_evaluator = PythonEvaluator()
|
||||
evaluated = python_evaluator.eval(context, parsed)
|
||||
|
||||
assert evaluated.status
|
||||
assert evaluated.value == 11
|
||||
|
||||
def test_i_can_eval_concept_with_ret(self):
|
||||
sheerka, context, one, the = self.init_concepts("one", Concept("the a", ret="a").def_var("a"))
|
||||
ret_val = get_ret_val_from_source_code(context, "test_using_context(the one)", {
|
||||
@@ -339,6 +323,17 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
|
||||
assert evaluated.status
|
||||
assert evaluated.value == "Print return values"
|
||||
|
||||
def test_i_can_update_sheerka_memory_using_assignation(self):
|
||||
sheerka, context = self.init_test().unpack()
|
||||
|
||||
parsed = PythonParser().parse(context, ParserInput("a = 10"))
|
||||
python_evaluator = PythonEvaluator()
|
||||
evaluated = python_evaluator.eval(context, parsed)
|
||||
|
||||
assert evaluated.status
|
||||
from_memory = sheerka.get_from_memory(context, "a")
|
||||
assert from_memory.obj == 10
|
||||
|
||||
@pytest.mark.parametrize("method, expected_status", [
|
||||
("return_return_value(True)", True),
|
||||
("return_return_value(False)", False),
|
||||
@@ -389,3 +384,13 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
|
||||
|
||||
assert evaluated.status
|
||||
assert evaluated.value == context.sheerka.get_rule_by_id(str(value)).name
|
||||
|
||||
def test_something(self):
|
||||
def func(**kwargs):
|
||||
for k, v in kwargs.items():
|
||||
print(f"{k=}, {v=}")
|
||||
|
||||
to_compile = "func(x=y)"
|
||||
ast_ = ast.parse(to_compile, mode="eval")
|
||||
compiled = compile(ast_, "<test>", mode="eval")
|
||||
eval(compiled, {"x": "hello", "y": "world", "func": func})
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import pytest
|
||||
|
||||
from core.builtin_concepts import BuiltinConcepts
|
||||
from core.concept import Concept, PROPERTIES_TO_SERIALIZE, simplec, CMV, CC
|
||||
from core.global_symbols import NotInit
|
||||
@@ -6,9 +7,7 @@ from core.sheerka.services.SheerkaConceptManager import SheerkaConceptManager
|
||||
from evaluators.MutipleSameSuccessEvaluator import MultipleSameSuccessEvaluator
|
||||
from evaluators.OneSuccessEvaluator import OneSuccessEvaluator
|
||||
from evaluators.PythonEvaluator import PythonEvalError
|
||||
from parsers.BaseNodeParser import SyaAssociativity
|
||||
from parsers.BnfNodeParser import Sequence, StrMatch, OrderedChoice, Optional, ConceptExpression
|
||||
|
||||
from tests.TestUsingFileBasedSheerka import TestUsingFileBasedSheerka
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
@@ -875,9 +874,9 @@ as:
|
||||
assert res[0].status
|
||||
|
||||
assert sheerka.get_weights("some_prop") == {'c:one|1001:': 1,
|
||||
'c:two|1002:': 2,
|
||||
'c:three|1003:': 3,
|
||||
'c:four|1004:': 4}
|
||||
'c:two|1002:': 2,
|
||||
'c:three|1003:': 3,
|
||||
'c:four|1004:': 4}
|
||||
|
||||
def test_i_can_evaluate_expression_when_using_token_concept(self):
|
||||
sheerka, context, one, two, three, is_less_than = self.init_concepts(
|
||||
@@ -949,7 +948,7 @@ as:
|
||||
sheerka = self.init_scenario(init)
|
||||
|
||||
# simulate that sheerka was stopped and restarted
|
||||
sheerka.om.clear(sheerka.CONCEPTS_GRAMMARS_ENTRY)
|
||||
sheerka.clear_bnf_definition()
|
||||
sheerka.om.get(SheerkaConceptManager.CONCEPTS_BY_KEY_ENTRY, "twenties").set_compiled({})
|
||||
|
||||
res = sheerka.evaluate_user_input("eval twenty one")
|
||||
@@ -1114,23 +1113,6 @@ as:
|
||||
assert len(res) == 1
|
||||
assert res[0].status
|
||||
|
||||
def test_i_can_eval_concepts_fed_with_functions(self):
|
||||
init = [
|
||||
"def concept inc a as a + 1",
|
||||
"def concept one as 1"
|
||||
]
|
||||
|
||||
def times_five(i):
|
||||
return i * 5
|
||||
|
||||
sheerka = self.init_scenario(init)
|
||||
sheerka.locals["times_five"] = times_five
|
||||
|
||||
res = sheerka.evaluate_user_input("eval inc times_five(one)")
|
||||
assert len(res) == 1
|
||||
assert res[0].status
|
||||
assert res[0].body == 6
|
||||
|
||||
def test_i_can_define_a_concept_when_where_clause_contains_the_name_of_the_variable(self):
|
||||
init = [
|
||||
"def concept x is a y as isa(x,y) pre is_question()",
|
||||
@@ -1231,7 +1213,8 @@ as:
|
||||
|
||||
def test_i_can_define_rules_priorities(self):
|
||||
sheerka, context, r1, r2 = self.init_test().with_format_rules(("True", "True"), ("False", "False")).unpack()
|
||||
sheerka.evaluate_user_input("def concept rule x > rule y where isinstance(x, int) and isinstance(y, int) as set_is_greater_than(__PRECEDENCE, r:|x:, r:|y:, 'Rule')")
|
||||
sheerka.evaluate_user_input(
|
||||
"def concept rule x > rule y where isinstance(x, int) and isinstance(y, int) as set_is_greater_than(__PRECEDENCE, r:|x:, r:|y:, 'Rule')")
|
||||
|
||||
res = sheerka.evaluate_user_input(f"eval rule {r1.id} > rule {r2.id}")
|
||||
|
||||
@@ -1242,6 +1225,18 @@ as:
|
||||
weights = sheerka.get_weights(BuiltinConcepts.PRECEDENCE, 'Rule')
|
||||
assert weights[r1.str_id] == weights[r2.str_id] + 1
|
||||
|
||||
def test_i_can_get_history_after_def_rule_parser(self):
|
||||
sheerka = self.get_sheerka()
|
||||
sheerka.save_execution_context = True
|
||||
sheerka.evaluate_user_input("when True then answer('that is true')")
|
||||
res = sheerka.evaluate_user_input("history()")
|
||||
|
||||
assert len(res) == 1
|
||||
assert res[0].status
|
||||
l = list(res[0].body.body)
|
||||
assert len(l) > 0
|
||||
sheerka.save_execution_context = False
|
||||
|
||||
|
||||
class TestSheerkaNonRegFile(TestUsingFileBasedSheerka):
|
||||
def test_i_can_def_several_concepts(self):
|
||||
|
||||
@@ -122,3 +122,20 @@ __default__
|
||||
assert captured.out == """one: (1001)one
|
||||
two: (1002)two
|
||||
"""
|
||||
|
||||
def test_i_can_retrieve_history(self, capsys):
|
||||
init = [
|
||||
"test()",
|
||||
]
|
||||
sheerka = self.init_scenario(init)
|
||||
capsys.readouterr()
|
||||
|
||||
sheerka.enable_process_return_values = True
|
||||
res = sheerka.evaluate_user_input(f"history()")
|
||||
|
||||
assert len(res) == 1
|
||||
assert res[0].status
|
||||
|
||||
captured = capsys.readouterr()
|
||||
assert " : test()" in captured.out
|
||||
assert " : history()" in captured.out
|
||||
|
||||
@@ -1169,7 +1169,7 @@ class TestBnfNodeParser(TestUsingMemoryBasedSheerka):
|
||||
:return:
|
||||
"""
|
||||
sheerka, context, parser = self.init_parser(init_from_sheerka=True)
|
||||
sheerka.concepts_grammars.clear() # to simulate restart
|
||||
sheerka.clear_bnf_definition() # to simulate restart
|
||||
text = "one thousand"
|
||||
|
||||
one = CC("one", body=DoNotResolve("one"))
|
||||
@@ -1195,7 +1195,7 @@ class TestBnfNodeParser(TestUsingMemoryBasedSheerka):
|
||||
:return:
|
||||
"""
|
||||
sheerka, context, parser = self.init_parser(init_from_sheerka=True)
|
||||
sheerka.concepts_grammars.clear() # to simulate restart
|
||||
sheerka.clear_bnf_definition() # to simulate restart
|
||||
text = "fifty one thousand"
|
||||
|
||||
one = CC("one", body=DoNotResolve("one"))
|
||||
@@ -1233,7 +1233,7 @@ class TestBnfNodeParser(TestUsingMemoryBasedSheerka):
|
||||
|
||||
def test_i_can_parse_one_hundred_thousand(self):
|
||||
sheerka, context, parser = self.init_parser(init_from_sheerka=True)
|
||||
sheerka.concepts_grammars.clear() # to simulate restart
|
||||
sheerka.clear_bnf_definition() # to simulate restart
|
||||
|
||||
text = "one hundred thousand"
|
||||
res = parser.parse(context, ParserInput(text))
|
||||
@@ -1244,7 +1244,7 @@ class TestBnfNodeParser(TestUsingMemoryBasedSheerka):
|
||||
|
||||
def test_i_can_parse_hundreds_like_expression(self):
|
||||
sheerka, context, parser = self.init_parser(init_from_sheerka=True)
|
||||
sheerka.concepts_grammars.clear()
|
||||
sheerka.clear_bnf_definition() # to simulate restart
|
||||
|
||||
text = "three hundred and thirty two"
|
||||
three = CC("three", body=DoNotResolve("three"))
|
||||
@@ -1280,7 +1280,7 @@ class TestBnfNodeParser(TestUsingMemoryBasedSheerka):
|
||||
|
||||
def test_i_can_parse_bnf_concept_mixed_with_isa_after_restart(self):
|
||||
sheerka, context, parser = self.init_parser(init_from_sheerka=True)
|
||||
sheerka.concepts_grammars.clear() # simulate restart
|
||||
sheerka.clear_bnf_definition() # to simulate restart
|
||||
for c in cmap.values():
|
||||
sheerka.get_by_id(c.id).set_bnf(None)
|
||||
|
||||
|
||||
@@ -1,11 +1,10 @@
|
||||
import pytest
|
||||
|
||||
from core.builtin_concepts import BuiltinConcepts
|
||||
from core.concept import Concept
|
||||
from core.rule import Rule
|
||||
from core.sheerka.services.SheerkaExecute import ParserInput
|
||||
from parsers.BaseNodeParser import SCN, SCWC, CN, UTN, CNC, RN
|
||||
from parsers.FunctionParser import FunctionParser, FN
|
||||
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
from tests.parsers.parsers_utils import compute_expected_array
|
||||
|
||||
|
||||
@@ -968,7 +968,7 @@ class TestSyaNodeParser(TestUsingMemoryBasedSheerka):
|
||||
def test_i_can_debug(self, expression, expected_debugs):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
sheerka.set_debug(context, True)
|
||||
sheerka.debug_var(context, "Sya")
|
||||
sheerka.set_debug_var(context, "Sya")
|
||||
res = parser.infix_to_postfix(context, ParserInput(expression))
|
||||
|
||||
assert len(res) == len(expected_debugs)
|
||||
@@ -983,7 +983,7 @@ class TestSyaNodeParser(TestUsingMemoryBasedSheerka):
|
||||
def test_i_can_debug_can_pop_using_star(self, settings):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
sheerka.set_debug(context, True)
|
||||
sheerka.debug_var(context, settings)
|
||||
sheerka.set_debug_var(context, settings)
|
||||
res = parser.infix_to_postfix(context, ParserInput("one plus two mult three"))
|
||||
|
||||
debug = [str(di) for di in res[0].debug]
|
||||
|
||||
@@ -1,13 +1,12 @@
|
||||
from core.builtin_concepts import ParserResultConcept, BuiltinConcepts
|
||||
from core.concept import Concept, CC
|
||||
from core.tokenizer import Tokenizer, TokenKind
|
||||
from parsers.SequenceNodeParser import SequenceNodeParser
|
||||
from parsers.BaseNodeParser import ConceptNode, UnrecognizedTokensNode, scnode, cnode, \
|
||||
utnode, SyaAssociativity, CN, CNC, UTN, SourceCodeWithConceptNode, SCWC, SourceCodeNode
|
||||
utnode, CN, CNC, UTN, SourceCodeWithConceptNode, SCWC, SourceCodeNode
|
||||
from parsers.BnfNodeParser import BnfNodeParser
|
||||
from parsers.SequenceNodeParser import SequenceNodeParser
|
||||
from parsers.SyaNodeParser import SyaNodeParser
|
||||
from parsers.UnrecognizedNodeParser import UnrecognizedNodeParser
|
||||
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
from tests.parsers.parsers_utils import compute_expected_array, get_node
|
||||
|
||||
@@ -208,49 +207,64 @@ class TestUnrecognizedNodeParser(TestUsingMemoryBasedSheerka):
|
||||
[CNC("twenties", source="twenty two", unit="two")])
|
||||
assert res.body.concept.get_compiled()["b"].get_compiled()["b"][0].body.body == expected_nodes
|
||||
|
||||
# def test_i_can_validate_and_evaluate_a_concept_node_with_python(self):
|
||||
# sheerka, context, parser = self.init_parser()
|
||||
#
|
||||
# node = get_input_nodes_from(
|
||||
# concepts_map,
|
||||
# "one plus 1 + 1",
|
||||
# CNC("plus",
|
||||
# a=UTN("one "),
|
||||
# b=UTN("1 + 1")))[0]
|
||||
#
|
||||
# res = UnrecognizedNodeParser().validate_concept_node(context, node)
|
||||
#
|
||||
# assert res.status
|
||||
# assert res.body.concept == concepts_map["plus"]
|
||||
# assert res.body.concept.get_compiled()["a"] == concepts_map["one"]
|
||||
# assert len(res.body.concept.get_compiled()["b"]) == 1
|
||||
# assert sheerka.isinstance(res.body.concept.get_compiled()["b"][0], BuiltinConcepts.RETURN_VALUE)
|
||||
# assert res.body.concept.get_compiled()["b"][0].status
|
||||
# assert res.body.concept.get_compiled()["b"][0].who == "parsers.Python"
|
||||
# assert res.body.concept.get_compiled()["b"][0].body.source == "1 + 1"
|
||||
#
|
||||
# # # evaluate
|
||||
# # context = self.get_context(sheerka, eval_body=True)
|
||||
# # evaluated = sheerka.evaluate_concept(context, res.body.concept)
|
||||
# # assert evaluated.body == 3
|
||||
def test_i_can_validate_and_evaluate_a_concept_node_with_python(self):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
|
||||
# def test_i_can_validate_and_evaluate_concept_when_bnf_concept(self):
|
||||
# sheerka, context, parser = self.init_parser()
|
||||
# node = get_concept_node(concepts_map, "one plus twenty one", "plus", "one", "twenty one")
|
||||
#
|
||||
# res = UnrecognizedNodeParser().validate_concept_node(context, node)
|
||||
#
|
||||
# assert res.status
|
||||
# assert res.body.concept == concepts_map["plus"]
|
||||
# assert res.body.concept.get_compiled()["a"] == concepts_map["one"]
|
||||
# assert len(res.body.concept.get_compiled()["b"]) == 1
|
||||
# assert res.body.concept.get_compiled()["b"][0].status
|
||||
# assert res.body.concept.get_compiled()["b"][0].who == "parsers.BnfNode"
|
||||
#
|
||||
# # evaluate
|
||||
# context = self.get_context(sheerka, eval_body=True)
|
||||
# evaluated = sheerka.evaluate_concept(context, res.body.concept)
|
||||
# assert evaluated.body == 22
|
||||
node = get_input_nodes_from(
|
||||
concepts_map,
|
||||
"one plus 1 + 1",
|
||||
CNC("plus",
|
||||
a=UTN("one "),
|
||||
b=UTN("1 + 1")))[0]
|
||||
|
||||
res = UnrecognizedNodeParser().validate_concept_node(context, node)
|
||||
|
||||
assert res.status
|
||||
concept_found = res.body.concept
|
||||
compiled = concept_found.get_compiled()
|
||||
assert concept_found == concepts_map["plus"]
|
||||
assert len(compiled["a"]) == 1
|
||||
assert sheerka.isinstance(compiled["a"][0], BuiltinConcepts.RETURN_VALUE)
|
||||
assert compiled["a"][0].body.body[0].concept.id == concepts_map["one"].id
|
||||
|
||||
assert len(compiled["b"]) == 1
|
||||
assert sheerka.isinstance(compiled["b"][0], BuiltinConcepts.RETURN_VALUE)
|
||||
assert compiled["b"][0].status
|
||||
assert compiled["b"][0].who == "parsers.Python"
|
||||
assert compiled["b"][0].body.source == "1 + 1"
|
||||
|
||||
# # evaluate
|
||||
context = self.get_context(sheerka, eval_body=True)
|
||||
evaluated = sheerka.evaluate_concept(context, res.body.concept)
|
||||
assert evaluated.body == 3
|
||||
|
||||
def test_i_can_validate_and_evaluate_concept_when_bnf_concept(self):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
node = get_input_nodes_from(
|
||||
concepts_map,
|
||||
"one plus twenty one",
|
||||
CNC("plus",
|
||||
a=UTN("one "),
|
||||
b=UTN("twenty one")))[0]
|
||||
|
||||
res = UnrecognizedNodeParser().validate_concept_node(context, node)
|
||||
|
||||
assert res.status
|
||||
concept_found = res.body.concept
|
||||
compiled = concept_found.get_compiled()
|
||||
assert concept_found == concepts_map["plus"]
|
||||
assert len(compiled["a"]) == 1
|
||||
assert sheerka.isinstance(compiled["a"][0], BuiltinConcepts.RETURN_VALUE)
|
||||
assert compiled["a"][0].body.body[0].concept.id == concepts_map["one"].id
|
||||
|
||||
assert len(compiled["b"]) == 1
|
||||
assert compiled["b"][0].status
|
||||
assert compiled["b"][0].who == "parsers.Bnf"
|
||||
|
||||
# evaluate
|
||||
context = self.get_context(sheerka, eval_body=True)
|
||||
evaluated = sheerka.evaluate_concept(context, res.body.concept)
|
||||
assert evaluated.body == 22
|
||||
|
||||
def test_i_can_parse_and_evaluate_unrecognized_python_node(self):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
|
||||
@@ -245,8 +245,10 @@ class TestReteConditions(TestUsingMemoryBasedSheerka):
|
||||
|
||||
matches = list(network.matches)
|
||||
assert len(matches) == 2
|
||||
assert matches[0].token.wmes == [wme3, wme2]
|
||||
assert matches[1].token.wmes == [wme1, wme3]
|
||||
# assert matches[0].token.wmes == [wme3, wme2]
|
||||
# assert matches[1].token.wmes == [wme1, wme3]
|
||||
assert len(matches[0].token.wmes) == 2
|
||||
assert len(matches[1].token.wmes) == 2
|
||||
|
||||
def test_i_can_manage_binding_conditions(self):
|
||||
network = ReteNetwork()
|
||||
|
||||
@@ -638,15 +638,26 @@ class TestReteNetwork(TestUsingMemoryBasedSheerka):
|
||||
network.remove_rule(rule3)
|
||||
assert len(list(p_node3.activations)) == 0
|
||||
|
||||
def test_rule_is_added_to_rete_network_when_it_is_created(self):
|
||||
def test_exec_rule_is_added_to_rete_network_when_it_is_created(self):
|
||||
sheerka, context, rule = self.init_test().with_exec_rules(("rule_name", "id.attr == 'value'", 'True')).unpack()
|
||||
evaluation_service = sheerka.services[SheerkaEvaluateRules.NAME]
|
||||
rete_network = evaluation_service.network
|
||||
|
||||
assert len(rete_network.pnodes) == 1
|
||||
assert rete_network.pnodes[0].rules[0] == rule
|
||||
assert rule.rete_net == rete_network
|
||||
assert len(rule.rete_p_nodes) > 0
|
||||
|
||||
def test_rule_is_removed_to_rete_network_when_it_is_deleted(self):
|
||||
def test_format_rule_is_not_added_to_rete_network_when_it_is_created(self):
|
||||
sheerka, context, rule = self.init_test().with_format_rules(("rule_name", "id.attr == 'value'", 'True')).unpack()
|
||||
evaluation_service = sheerka.services[SheerkaEvaluateRules.NAME]
|
||||
rete_network = evaluation_service.network
|
||||
|
||||
assert len(rete_network.pnodes) == 0
|
||||
assert rule.rete_net is None
|
||||
assert len(rule.rete_p_nodes) == 0
|
||||
|
||||
def test_rule_is_removed_from_rete_network_when_it_is_deleted(self):
|
||||
sheerka, context, rule = self.init_test().with_exec_rules(("id.attr == 'value'", 'True')).unpack()
|
||||
evaluation_service = sheerka.services[SheerkaEvaluateRules.NAME]
|
||||
rete_network = evaluation_service.network
|
||||
@@ -654,6 +665,15 @@ class TestReteNetwork(TestUsingMemoryBasedSheerka):
|
||||
sheerka.remove_rule(context, rule)
|
||||
assert len(rete_network.pnodes) == 0
|
||||
|
||||
def test_rule_is_removed_from_rete_network_when_it_is_deleted_from_another_ontology(self):
|
||||
sheerka, context, rule = self.init_test().with_exec_rules(("id.attr == 'value'", 'True')).unpack()
|
||||
evaluation_service = sheerka.services[SheerkaEvaluateRules.NAME]
|
||||
rete_network = evaluation_service.network
|
||||
|
||||
sheerka.push_ontology(context, "new ontology")
|
||||
sheerka.remove_rule(context, rule)
|
||||
assert len(rete_network.pnodes) == 0
|
||||
|
||||
def test_rules_are_removed_upon_ontology_removal(self):
|
||||
sheerka, context = self.init_test().unpack()
|
||||
service = sheerka.services[SheerkaRuleManager.NAME]
|
||||
|
||||
Reference in New Issue
Block a user