You must now use 'eval' to get the body of a concept
This commit is contained in:
@@ -12,12 +12,13 @@ from parsers.ConceptLexerParser import Sequence, StrMatch, ZeroOrMore, ConceptMa
|
||||
from parsers.BnfParser import BnfParser
|
||||
from parsers.DefaultParser import DefConceptNode, NameNode
|
||||
from parsers.PythonParser import PythonNode, PythonParser
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
return ExecutionContext("test", "xxx", sheerka)
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def get_concept(name, where=None, pre=None, post=None, body=None, definition=None):
|
||||
@@ -178,4 +179,4 @@ def test_i_can_get_props_from_definition():
|
||||
parsing_expression = Sequence(ConceptMatch('mult'), ZeroOrMore(Sequence(StrMatch("+"), ConceptMatch("add"))))
|
||||
ret_val = get_concept_definition("mult (('+'|'-') add)?", parsing_expression)
|
||||
|
||||
assert AddConceptEvaluator.get_props(get_context(), ret_val, []) == ["add", "mult"]
|
||||
assert AddConceptEvaluator.get_props(get_context(), ret_val, []) == ["add", "mult"]
|
||||
|
||||
@@ -6,12 +6,13 @@ from core.sheerka import Sheerka, ExecutionContext
|
||||
from core.tokenizer import Tokenizer
|
||||
from evaluators.AddConceptInSetEvaluator import AddConceptInSetEvaluator
|
||||
from parsers.DefaultParser import IsaConceptNode, NameNode
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
return ExecutionContext("test", "xxx", sheerka)
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def get_ret_val(concept_name, concept_set_name):
|
||||
@@ -74,6 +75,23 @@ def test_i_can_add_concept_to_a_set_of_concept():
|
||||
assert context.sheerka.isinstance(res.value, BuiltinConcepts.SUCCESS)
|
||||
|
||||
|
||||
def test_i_can_add_concept_with_a_body_to_a_set_of_concept():
|
||||
context = get_context()
|
||||
foo = Concept("foo", body="1")
|
||||
context.sheerka.set_id_if_needed(foo, False)
|
||||
context.sheerka.add_in_cache(foo)
|
||||
|
||||
bar = Concept("bar")
|
||||
context.sheerka.set_id_if_needed(bar, False)
|
||||
context.sheerka.add_in_cache(bar)
|
||||
|
||||
ret_val = get_ret_val("foo", "bar")
|
||||
res = AddConceptInSetEvaluator().eval(context, ret_val)
|
||||
|
||||
assert res.status
|
||||
assert context.sheerka.isinstance(res.value, BuiltinConcepts.SUCCESS)
|
||||
|
||||
|
||||
def test_i_cannot_add_the_same_concept_twice():
|
||||
context = get_context()
|
||||
foo = Concept("foo")
|
||||
|
||||
@@ -7,13 +7,14 @@ from parsers.BaseParser import UnexpectedTokenErrorNode
|
||||
from parsers.BnfParser import BnfParser, UnexpectedEndOfFileError
|
||||
from parsers.ConceptLexerParser import StrMatch, Optional, ZeroOrMore, OrderedChoice, Sequence, OneOrMore, \
|
||||
ConceptLexerParser, ConceptNode, ConceptMatch
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
|
||||
return ExecutionContext("sheerka", "xxxx", sheerka)
|
||||
return ExecutionContext("sheerka", Event(), sheerka)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("expression, expected", [
|
||||
|
||||
@@ -6,12 +6,13 @@ from core.sheerka import Sheerka, ExecutionContext
|
||||
from evaluators.ConceptEvaluator import ConceptEvaluator
|
||||
from parsers.BaseParser import BaseParser
|
||||
from parsers.ExactConceptParser import ExactConceptParser
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
return ExecutionContext("test", "xxx", sheerka)
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def get_return_value(concept, source=None):
|
||||
@@ -55,7 +56,7 @@ def test_i_can_evaluate_concept():
|
||||
assert result.parents == [item]
|
||||
|
||||
|
||||
def test_body_is_returned_when_defined():
|
||||
def test_body_is_returned_when_defined_and_requested():
|
||||
context = get_context()
|
||||
concept = Concept(name="foo",
|
||||
body="'I have a value'",
|
||||
@@ -63,7 +64,7 @@ def test_body_is_returned_when_defined():
|
||||
pre="2",
|
||||
post="3").set_prop("a", "4").set_prop("b", "5")
|
||||
|
||||
evaluator = ConceptEvaluator()
|
||||
evaluator = ConceptEvaluator(return_body=True)
|
||||
item = get_return_value(concept)
|
||||
result = evaluator.eval(context, item)
|
||||
|
||||
@@ -73,7 +74,25 @@ def test_body_is_returned_when_defined():
|
||||
assert result.parents == [item]
|
||||
|
||||
|
||||
def test_i_cannot_eval_if_with_the_same_name_is_defined_in_the_context():
|
||||
def test_body_is_not_returned_if_not_requested():
|
||||
context = get_context()
|
||||
concept = Concept(name="foo",
|
||||
body="'I have a value'",
|
||||
where="1",
|
||||
pre="2",
|
||||
post="3").set_prop("a", "4").set_prop("b", "5")
|
||||
|
||||
evaluator = ConceptEvaluator(return_body=False) # which is the default behaviour
|
||||
item = get_return_value(concept)
|
||||
result = evaluator.eval(context, item)
|
||||
|
||||
assert result.who == evaluator.name
|
||||
assert result.status
|
||||
assert result.value == concept
|
||||
assert result.parents == [item]
|
||||
|
||||
|
||||
def test_i_can_eval_if_with_the_same_name_is_defined_in_the_context():
|
||||
# If we evaluate Concept("foo", body="a").set_prop("a", "'property_a'")
|
||||
# ConceptEvaluator will be called to resolve 'a' while we know that 'a' refers to the string 'property_a'
|
||||
|
||||
@@ -84,8 +103,8 @@ def test_i_cannot_eval_if_with_the_same_name_is_defined_in_the_context():
|
||||
item = get_return_value(concept)
|
||||
result = ConceptEvaluator().eval(context, item)
|
||||
|
||||
assert not result.status
|
||||
assert context.sheerka.isinstance(result.value, BuiltinConcepts.NOT_FOR_ME)
|
||||
assert result.status
|
||||
assert result.value == "'some_other_value'"
|
||||
|
||||
|
||||
def test_i_cannot_recognize_a_concept_if_one_of_the_prop_is_unknown():
|
||||
|
||||
@@ -4,6 +4,7 @@ from core.concept import Concept
|
||||
from core.sheerka import Sheerka, ExecutionContext
|
||||
from parsers.ConceptLexerParser import ConceptLexerParser, ConceptNode, Sequence, StrMatch, OrderedChoice, Optional, \
|
||||
ParsingExpressionVisitor, TerminalNode, NonTerminalNode, LexerNode, ConceptMatch, ZeroOrMore, OneOrMore
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
class ConceptVisitor(ParsingExpressionVisitor):
|
||||
@@ -849,4 +850,4 @@ def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
|
||||
return ExecutionContext("sheerka", "xxxx", sheerka)
|
||||
return ExecutionContext("sheerka", Event(), sheerka)
|
||||
|
||||
@@ -4,14 +4,15 @@ from core.builtin_concepts import ReturnValueConcept, ParserResultConcept
|
||||
from core.concept import Concept
|
||||
from core.sheerka import Sheerka, ExecutionContext
|
||||
from evaluators.ConceptNodeEvaluator import ConceptNodeEvaluator
|
||||
from parsers.ConceptLexerParser import ConceptNode, ConceptLexerParser, NonTerminalNode, Sequence, TerminalNode, \
|
||||
from parsers.ConceptLexerParser import ConceptNode, ConceptLexerParser, Sequence, TerminalNode, \
|
||||
StrMatch, Optional, OrderedChoice, ZeroOrMore
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
return ExecutionContext("test", "xxx", sheerka)
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def get_return_value(nodes, source):
|
||||
|
||||
@@ -11,49 +11,8 @@ from parsers.DefaultParser import UnexpectedTokenErrorNode, DefConceptNode
|
||||
from parsers.BnfParser import BnfParser
|
||||
|
||||
|
||||
# def nop():
|
||||
# return NopNode()
|
||||
#
|
||||
#
|
||||
# def n(number):
|
||||
# return NumberNode([], number)
|
||||
#
|
||||
#
|
||||
# def s(string, quote="'"):
|
||||
# return StringNode([], string, quote)
|
||||
#
|
||||
#
|
||||
# def v(name):
|
||||
# return VariableNode([], name)
|
||||
#
|
||||
#
|
||||
# def t():
|
||||
# return TrueNode([])
|
||||
#
|
||||
#
|
||||
# def f():
|
||||
# return FalseNode([])
|
||||
#
|
||||
#
|
||||
# def null():
|
||||
# return NullNode([])
|
||||
#
|
||||
#
|
||||
# def b(operator, left, right):
|
||||
# return BinaryNode([], operator, left, right)
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
#
|
||||
# def compare_ast(left, right):
|
||||
# left_as_string = ast.dump(left)
|
||||
# left_as_string = left_as_string.replace(", ctx=Load()", "")
|
||||
# left_as_string = left_as_string.replace(", kind=None", "")
|
||||
#
|
||||
# right_as_string = right if isinstance(right, str) else ast.dump(right)
|
||||
# right_as_string = right_as_string.replace(", ctx=Load()", "")
|
||||
# right_as_string = right_as_string.replace(", kind=None", "")
|
||||
#
|
||||
# return left_as_string == right_as_string
|
||||
#
|
||||
|
||||
def get_def_concept(name, where=None, pre=None, post=None, body=None, definition=None):
|
||||
def_concept = DefConceptNode([], name=NameNode(list(Tokenizer(name))))
|
||||
@@ -78,7 +37,7 @@ def get_def_concept(name, where=None, pre=None, post=None, body=None, definition
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
return ExecutionContext("test", "xxx", sheerka)
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def get_concept_part(part):
|
||||
@@ -104,45 +63,6 @@ def get_concept_part(part):
|
||||
if isinstance(part, ReturnValueConcept):
|
||||
return part
|
||||
|
||||
# @pytest.mark.parametrize("text, expected", [
|
||||
# ("1", n(1)),
|
||||
# ("+1", n(1)),
|
||||
# ("-1", n(-1)),
|
||||
# ("'foo'", s("foo")),
|
||||
# ("identifier", v("identifier")),
|
||||
# ("true", t()),
|
||||
# ("false", f()),
|
||||
# ("null", null()),
|
||||
# ("1 * 2", b(TokenKind.STAR, n(1), n(2))),
|
||||
# ("1 * 2/3", b(TokenKind.STAR, n(1), b(TokenKind.SLASH, n(2), n(3)))),
|
||||
# ("1 + 2", b(TokenKind.PLUS, n(1), n(2))),
|
||||
# ("1 + 2 - 3", b(TokenKind.PLUS, n(1), b(TokenKind.MINUS, n(2), n(3)))),
|
||||
# ("1 + 2-3", b(TokenKind.PLUS, n(1), b(TokenKind.PLUS, n(2), n(-3)))),
|
||||
# ("1 + 2 +-3", b(TokenKind.PLUS, n(1), b(TokenKind.PLUS, n(2), n(-3)))),
|
||||
# ("1 + 2 * 3", b(TokenKind.PLUS, n(1), b(TokenKind.STAR, n(2), n(3)))),
|
||||
# ("1 * 2 + 3", b(TokenKind.PLUS, b(TokenKind.STAR, n(1), n(2)), n(3))),
|
||||
# ("(1 + 2) * 3", b(TokenKind.STAR, b(TokenKind.PLUS, n(1), n(2)), n(3))),
|
||||
# ("1 * (2 + 3)", b(TokenKind.STAR, n(1), b(TokenKind.PLUS, n(2), n(3)))),
|
||||
# ])
|
||||
# def test_i_can_parse_simple_expression(text, expected):
|
||||
# parser = DefaultParser(text, None)
|
||||
# ast = parser.parse()
|
||||
# assert ast.is_same(expected)
|
||||
#
|
||||
#
|
||||
# @pytest.mark.parametrize("text, token_found, expected_tokens", [
|
||||
# ("1+", TokenKind.EOF,
|
||||
# [TokenKind.NUMBER, TokenKind.STRING, TokenKind.IDENTIFIER, 'true', 'false', 'null', TokenKind.LPAR]),
|
||||
# ("(1+1", TokenKind.EOF, [TokenKind.RPAR])
|
||||
# ])
|
||||
# def test_i_can_detect_unexpected_end_of_code(text, token_found, expected_tokens):
|
||||
# parser = DefaultParser(text, None)
|
||||
# parser.parse()
|
||||
#
|
||||
# assert parser.has_error
|
||||
# assert parser.error_sink[0].tokens[0].type == token_found
|
||||
# assert parser.error_sink[0].expected_tokens == expected_tokens
|
||||
|
||||
|
||||
@pytest.mark.parametrize("text, expected", [
|
||||
("def concept hello", get_def_concept(name="hello")),
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
import pytest
|
||||
|
||||
from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts
|
||||
from core.concept import Concept
|
||||
from core.sheerka import Sheerka, ExecutionContext
|
||||
from evaluators.EvalEvaluator import EvalEvaluator
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def r(value, status=True):
|
||||
return ReturnValueConcept("some_name", status, value)
|
||||
|
||||
|
||||
eval_requested = ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.CONCEPT_EVAL_REQUESTED))
|
||||
|
||||
|
||||
def test_i_can_match_and_eval():
|
||||
context = get_context()
|
||||
|
||||
to_eval1 = ReturnValueConcept("some_name", True, Concept(name="2", body="to eval"))
|
||||
to_eval2 = ReturnValueConcept("some_name", True, Concept(name="3", body="also to eval"))
|
||||
|
||||
return_values = [
|
||||
ReturnValueConcept("some_name", True, "not to eval"),
|
||||
ReturnValueConcept("some_name", True, Concept(name="not to eval")),
|
||||
ReturnValueConcept("some_name", False, Concept(name="1", body="not to eval")),
|
||||
to_eval1,
|
||||
to_eval2,
|
||||
eval_requested
|
||||
]
|
||||
|
||||
evaluator = EvalEvaluator()
|
||||
assert evaluator.matches(context, return_values)
|
||||
|
||||
evaluated = evaluator.eval(context, return_values)
|
||||
assert len(evaluated) == 2
|
||||
assert evaluated[0].value == to_eval1.body.body
|
||||
assert evaluated[0].parents == [to_eval1, eval_requested]
|
||||
|
||||
assert evaluated[1].value == to_eval2.body.body
|
||||
assert evaluated[1].parents == [to_eval2, eval_requested]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("return_values, expected", [
|
||||
([r(Concept("foo", body="bar")), eval_requested], True),
|
||||
([r(Concept("status is false", body="bar"), False), eval_requested], False),
|
||||
([r("string_value"), eval_requested], False),
|
||||
([r(Concept("no body")), eval_requested], False),
|
||||
([r(Concept("eval requested missing", body="bar"))], False),
|
||||
])
|
||||
def test_i_cannot_match_if_eval_request_is_not_present(return_values, expected):
|
||||
context = get_context()
|
||||
assert EvalEvaluator().matches(context, return_values) == expected
|
||||
@@ -3,6 +3,7 @@ from core.concept import Concept, Property
|
||||
from core.sheerka import Sheerka, ExecutionContext
|
||||
from core.tokenizer import Tokenizer
|
||||
from parsers.ExactConceptParser import ExactConceptParser
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def test_i_can_compute_combinations():
|
||||
@@ -130,7 +131,7 @@ def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
|
||||
return ExecutionContext("sheerka", "xxxx", sheerka)
|
||||
return ExecutionContext("sheerka", Event(), sheerka)
|
||||
|
||||
|
||||
def get_concept(name, variables):
|
||||
|
||||
@@ -1,12 +1,13 @@
|
||||
from core.builtin_concepts import BuiltinConcepts
|
||||
from core.concept import Concept
|
||||
from core.sheerka import ExecutionContext
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def test_id_is_incremented_by_event_digest():
|
||||
a = ExecutionContext("foo", "event_1", None)
|
||||
b = ExecutionContext("foo", "event_1", None)
|
||||
c = ExecutionContext("foo", "event_2", None)
|
||||
a = ExecutionContext("foo", Event("event_1"), None)
|
||||
b = ExecutionContext("foo", Event("event_1"), None)
|
||||
c = ExecutionContext("foo", Event("event_2"), None)
|
||||
d = b.push()
|
||||
e = c.push()
|
||||
|
||||
@@ -18,17 +19,19 @@ def test_id_is_incremented_by_event_digest():
|
||||
|
||||
|
||||
def test_some_properties_are_given_to_the_child():
|
||||
a = ExecutionContext("foo", "event_1", "fake_sheerka",
|
||||
a = ExecutionContext("foo", Event("event_1"), "fake_sheerka",
|
||||
desc="some description",
|
||||
obj=Concept("foo"),
|
||||
step=BuiltinConcepts.EVALUATION,
|
||||
iteration=15,
|
||||
concepts={"bar": Concept("bar")})
|
||||
a.preprocess = set()
|
||||
a.preprocess.add("preprocess")
|
||||
|
||||
b = a.push()
|
||||
|
||||
assert b.who == a.who
|
||||
assert b.event_digest == a.event_digest
|
||||
assert b.event == a.event
|
||||
assert b.sheerka == a.sheerka
|
||||
assert b.desc == ""
|
||||
assert b.obj == a.obj
|
||||
@@ -37,3 +40,4 @@ def test_some_properties_are_given_to_the_child():
|
||||
assert b.concepts == a.concepts
|
||||
assert b.id == a.id + 1
|
||||
assert b._tab == a._tab + " "
|
||||
assert b.preprocess == a.preprocess
|
||||
|
||||
@@ -4,12 +4,13 @@ from core.sheerka import Sheerka, ExecutionContext
|
||||
from evaluators.BaseEvaluator import BaseEvaluator
|
||||
from evaluators.MutipleSameSuccessEvaluator import MultipleSameSuccessEvaluator
|
||||
from parsers.BaseParser import BaseParser
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
return ExecutionContext("test", "xxx", sheerka)
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def test_i_can_match_and_eval():
|
||||
@@ -21,7 +22,7 @@ def test_i_can_match_and_eval():
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name2", False, "Not relevant"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="1", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="2", body="value")),
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.AFTER_EVALUATION))
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.REDUCE_REQUESTED))
|
||||
]
|
||||
|
||||
evaluator = MultipleSameSuccessEvaluator()
|
||||
@@ -29,7 +30,7 @@ def test_i_can_match_and_eval():
|
||||
|
||||
evaluated = evaluator.eval(context, return_values)
|
||||
assert evaluated.status
|
||||
assert evaluated.value == "value"
|
||||
assert evaluated.value == Concept(name="1", body="value") # the first concept is returned
|
||||
|
||||
|
||||
def test_i_can_match_and_eval_when_no_body():
|
||||
@@ -41,7 +42,7 @@ def test_i_can_match_and_eval_when_no_body():
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name2", False, "Not relevant"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="1")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="1")),
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.AFTER_EVALUATION))
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.REDUCE_REQUESTED))
|
||||
]
|
||||
|
||||
evaluator = MultipleSameSuccessEvaluator()
|
||||
@@ -61,7 +62,7 @@ def test_i_can_match_and_eval_when_value_is_not_a_concept():
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name2", False, "Not relevant"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, "value"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, "value"),
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.AFTER_EVALUATION))
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.REDUCE_REQUESTED))
|
||||
]
|
||||
|
||||
evaluator = MultipleSameSuccessEvaluator()
|
||||
@@ -72,6 +73,54 @@ def test_i_can_match_and_eval_when_value_is_not_a_concept():
|
||||
assert evaluated.value == "value"
|
||||
|
||||
|
||||
def test_i_can_match_and_eval_when_at_least_one_value_is_a_concept_concept_evaluator_first():
|
||||
context = get_context()
|
||||
sheerka = context.sheerka
|
||||
|
||||
return_values = [
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "Not relevant"),
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name2", False, "Not relevant"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "Python", True, "value"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "other", True, "value"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "Python", True, Concept(name="2", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "Concept", True, Concept(name="1", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "Python", True, Concept(name="3", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "other", True, "value"),
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.REDUCE_REQUESTED))
|
||||
]
|
||||
|
||||
evaluator = MultipleSameSuccessEvaluator()
|
||||
assert evaluator.matches(context, return_values)
|
||||
|
||||
evaluated = evaluator.eval(context, return_values)
|
||||
assert evaluated.status
|
||||
assert evaluated.value == Concept(name="1", body="value") # the concept is returned, not the value
|
||||
|
||||
|
||||
def test_i_can_match_and_eval_when_at_least_one_value_is_a_concept_python_evaluator_first():
|
||||
context = get_context()
|
||||
sheerka = context.sheerka
|
||||
|
||||
return_values = [
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "Not relevant"),
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name2", False, "Not relevant"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "Python", True, "value"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "other", True, "value"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "other", True, Concept(name="2", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "Python", True, Concept(name="1", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "other", True, Concept(name="3", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "other", True, "value"),
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.REDUCE_REQUESTED))
|
||||
]
|
||||
|
||||
evaluator = MultipleSameSuccessEvaluator()
|
||||
assert evaluator.matches(context, return_values)
|
||||
|
||||
evaluated = evaluator.eval(context, return_values)
|
||||
assert evaluated.status
|
||||
assert evaluated.value == Concept(name="1", body="value") # the concept is returned, not the value
|
||||
|
||||
|
||||
def test_i_can_match_even_if_the_value_are_not_the_same_but_eval_will_fail():
|
||||
context = get_context()
|
||||
sheerka = context.sheerka
|
||||
@@ -81,7 +130,7 @@ def test_i_can_match_even_if_the_value_are_not_the_same_but_eval_will_fail():
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name2", False, "Not relevant"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="1", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="2", body="value2")),
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.AFTER_EVALUATION))
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.REDUCE_REQUESTED))
|
||||
]
|
||||
|
||||
evaluator = MultipleSameSuccessEvaluator()
|
||||
@@ -98,7 +147,7 @@ def test_i_can_match_even_if_the_value_are_not_the_same_but_eval_will_fail_when_
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name2", False, "Not relevant"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="1")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="2")),
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.AFTER_EVALUATION))
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.REDUCE_REQUESTED))
|
||||
]
|
||||
|
||||
evaluator = MultipleSameSuccessEvaluator()
|
||||
@@ -113,13 +162,13 @@ def test_i_can_match_if_no_parser():
|
||||
return_values = [
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="1", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="2", body="value")),
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.AFTER_EVALUATION))
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.REDUCE_REQUESTED))
|
||||
]
|
||||
|
||||
assert MultipleSameSuccessEvaluator().matches(context, return_values)
|
||||
|
||||
|
||||
def test_i_cannot_match_if_not_after_evaluation():
|
||||
def test_i_cannot_match_if_not_reduced_requested():
|
||||
context = get_context()
|
||||
sheerka = context.sheerka
|
||||
|
||||
@@ -129,7 +178,7 @@ def test_i_cannot_match_if_not_after_evaluation():
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="1", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="2", body="value")),
|
||||
ReturnValueConcept("some_name", True, Concept(name="2", body="value")),
|
||||
# ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.AFTER_EVALUATION))
|
||||
# ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.REDUCE_REQUESTED))
|
||||
]
|
||||
|
||||
assert not MultipleSameSuccessEvaluator().matches(context, return_values)
|
||||
@@ -145,7 +194,7 @@ def test_i_cannot_match_if_only_one_successful_evaluator():
|
||||
# ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="1", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="2", body="value")),
|
||||
ReturnValueConcept("some_name", True, Concept(name="2", body="value")),
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.AFTER_EVALUATION))
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.REDUCE_REQUESTED))
|
||||
]
|
||||
|
||||
assert not MultipleSameSuccessEvaluator().matches(context, return_values)
|
||||
@@ -160,41 +209,8 @@ def test_i_cannot_match_if_at_least_one_parser_is_successful():
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name2", True, "Not relevant"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="1", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="2", body="value")),
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.AFTER_EVALUATION))
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.REDUCE_REQUESTED))
|
||||
]
|
||||
|
||||
assert not MultipleSameSuccessEvaluator().matches(context, return_values)
|
||||
|
||||
|
||||
def test_i_cannot_match_if_i_have_unlisted_return_value_in_success():
|
||||
context = get_context()
|
||||
sheerka = context.sheerka
|
||||
|
||||
return_values = [
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "Not relevant"),
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name2", False, "Not relevant"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="1", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="2", body="value")),
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.AFTER_EVALUATION)),
|
||||
ReturnValueConcept("some_name", True, "not relevant"),
|
||||
|
||||
]
|
||||
|
||||
assert not MultipleSameSuccessEvaluator().matches(context, return_values)
|
||||
|
||||
|
||||
def test_i_cannot_match_if_i_have_unlisted_return_value_in_error():
|
||||
context = get_context()
|
||||
sheerka = context.sheerka
|
||||
|
||||
return_values = [
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "Not relevant"),
|
||||
ReturnValueConcept(BaseParser.PREFIX + "some_name2", False, "Not relevant"),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="1", body="value")),
|
||||
ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, Concept(name="2", body="value")),
|
||||
ReturnValueConcept("some_name", True, sheerka.new(BuiltinConcepts.AFTER_EVALUATION)),
|
||||
ReturnValueConcept("some_name", False, "not relevant"),
|
||||
|
||||
]
|
||||
|
||||
assert not MultipleSameSuccessEvaluator().matches(context, return_values)
|
||||
|
||||
@@ -0,0 +1,80 @@
|
||||
import pytest
|
||||
|
||||
from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts
|
||||
from core.concept import Concept
|
||||
from core.sheerka import Sheerka, ExecutionContext
|
||||
from evaluators.OneErrorEvaluator import OneErrorEvaluator
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def r(value, status=True):
|
||||
return ReturnValueConcept(value, status, value)
|
||||
|
||||
|
||||
reduce_requested = ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.REDUCE_REQUESTED))
|
||||
|
||||
|
||||
@pytest.mark.parametrize("return_values, expected", [
|
||||
([r("evaluators.one error", False), reduce_requested], True),
|
||||
([r("evaluators.one error", False), r("failed", False), r("failed", False), reduce_requested], True),
|
||||
([r("evaluators.error", False), r("not a parser in success"), reduce_requested], True),
|
||||
([r("evaluators.no reduce required", False), r("failed", False), r("failed", False)], False),
|
||||
([r("evaluators.no reduce required", False)], False),
|
||||
([r("evaluators.error", False), r("evaluators.success"), reduce_requested], False),
|
||||
([r("evaluators.error", False), r("parsers.success"), reduce_requested], False),
|
||||
([r("evaluators.success"), r("not an evaluator in error", False), reduce_requested], False),
|
||||
([r("evaluators.error", False), r("evaluators.another error", False), reduce_requested], False),
|
||||
])
|
||||
def test_i_can_match(return_values, expected):
|
||||
context = get_context()
|
||||
assert OneErrorEvaluator().matches(context, return_values) == expected
|
||||
|
||||
|
||||
def test_i_can_eval():
|
||||
context = get_context()
|
||||
|
||||
return_values = [
|
||||
r("evaluators.one error", False),
|
||||
r("parsers.failed", False),
|
||||
r("parsers.failed", False),
|
||||
reduce_requested
|
||||
]
|
||||
|
||||
evaluator = OneErrorEvaluator()
|
||||
evaluator.matches(context, return_values)
|
||||
res = evaluator.eval(context, return_values)
|
||||
|
||||
assert not res.status
|
||||
assert res.body == "evaluators.one error"
|
||||
assert len(res.parents) == 4
|
||||
|
||||
|
||||
def test_unwanted_return_values_are_not_eaten():
|
||||
context = get_context()
|
||||
|
||||
a_successful_concept = r("successful concept")
|
||||
a_concept_in_error = r("concept in error", False)
|
||||
return_values = [
|
||||
r("evaluators.one error", False),
|
||||
r("parsers.failed", False),
|
||||
r("parsers.failed", False),
|
||||
a_successful_concept,
|
||||
a_concept_in_error,
|
||||
reduce_requested
|
||||
]
|
||||
|
||||
evaluator = OneErrorEvaluator()
|
||||
evaluator.matches(context, return_values)
|
||||
res = evaluator.eval(context, return_values)
|
||||
|
||||
assert not res.status
|
||||
assert res.body == "evaluators.one error"
|
||||
assert len(res.parents) == 4
|
||||
|
||||
assert a_successful_concept not in res.parents
|
||||
@@ -0,0 +1,79 @@
|
||||
import pytest
|
||||
|
||||
from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts
|
||||
from core.concept import Concept
|
||||
from core.sheerka import Sheerka, ExecutionContext
|
||||
from evaluators.OneSuccessEvaluator import OneSuccessEvaluator
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def r(value, status=True):
|
||||
return ReturnValueConcept(value, status, value)
|
||||
|
||||
|
||||
reduce_requested = ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.REDUCE_REQUESTED))
|
||||
|
||||
|
||||
@pytest.mark.parametrize("return_values, expected", [
|
||||
([r("evaluators.one success"), reduce_requested], True),
|
||||
([r("evaluators.one success"), r("failed", False), r("failed", False), reduce_requested], True),
|
||||
([r("evaluators.no reduce required"), r("failed", False), r("failed", False)], False),
|
||||
([r("evaluators.no reduce required")], False),
|
||||
([r("evaluators.failed", False), r("failed", False), r("failed", False), reduce_requested], False),
|
||||
([r("evaluators.failed", False), r("not evaluator success"), reduce_requested], False),
|
||||
([r("evaluators.success"), r("evaluators.another success"), reduce_requested], False),
|
||||
([r("evaluators.one success"), r("other success"), r("failed", False), reduce_requested], True),
|
||||
([r("evaluators.one success"), r("parsers.success"), reduce_requested], False),
|
||||
])
|
||||
def test_i_can_match(return_values, expected):
|
||||
context = get_context()
|
||||
assert OneSuccessEvaluator().matches(context, return_values) == expected
|
||||
|
||||
|
||||
def test_i_can_eval():
|
||||
context = get_context()
|
||||
|
||||
return_values = [
|
||||
r("evaluators.one success"),
|
||||
r("failed", False),
|
||||
r("failed", False),
|
||||
reduce_requested
|
||||
]
|
||||
|
||||
evaluator = OneSuccessEvaluator()
|
||||
matches = evaluator.matches(context, return_values)
|
||||
res = evaluator.eval(context, return_values)
|
||||
|
||||
assert matches
|
||||
assert res.status
|
||||
assert res.body == "evaluators.one success"
|
||||
assert len(res.parents) == 4
|
||||
|
||||
|
||||
def test_i_do_not_eat_the_other_success():
|
||||
context = get_context()
|
||||
|
||||
not_a_parser_success = r("other success")
|
||||
return_values = [
|
||||
r("evaluators.one success"),
|
||||
not_a_parser_success,
|
||||
r("failed", False),
|
||||
reduce_requested
|
||||
]
|
||||
|
||||
evaluator = OneSuccessEvaluator()
|
||||
matches = evaluator.matches(context, return_values)
|
||||
res = evaluator.eval(context, return_values)
|
||||
|
||||
assert matches
|
||||
assert res.status
|
||||
assert res.body == "evaluators.one success"
|
||||
assert len(res.parents) == 3
|
||||
|
||||
assert not_a_parser_success not in res.parents
|
||||
@@ -0,0 +1,52 @@
|
||||
import pytest
|
||||
|
||||
from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept
|
||||
from core.concept import Concept
|
||||
from core.sheerka import Sheerka, ExecutionContext
|
||||
from evaluators.PrepareEvalEvaluator import PrepareEvalEvaluator
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("ret_val, expected", [
|
||||
(ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.USER_INPUT, body="eval 1 + 1")), True),
|
||||
(ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.USER_INPUT, body=" eval 1 + 1")), True),
|
||||
(ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.USER_INPUT, body="eval")), False),
|
||||
(ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.USER_INPUT, body="1+1")), False),
|
||||
(ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.USER_INPUT, body="")), False),
|
||||
(ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.USER_INPUT, body="eval ")), False),
|
||||
(ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.USER_INPUT, body=[])), False),
|
||||
(ReturnValueConcept("some_name", True, Concept("foo")), False),
|
||||
(ReturnValueConcept("some_name", True, "not a concept"), False),
|
||||
(ReturnValueConcept("some_name", False, Concept(key=BuiltinConcepts.USER_INPUT, body="eval 1 + 1")), False),
|
||||
(ReturnValueConcept("some_name", False, Concept(key=BuiltinConcepts.USER_INPUT, body=" eval 1 + 1")), False),
|
||||
])
|
||||
def test_i_can_match(ret_val, expected):
|
||||
context = get_context()
|
||||
assert PrepareEvalEvaluator().matches(context, ret_val) == expected
|
||||
|
||||
|
||||
@pytest.mark.parametrize("ret_val, expected", [
|
||||
(ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.USER_INPUT, body="eval 1 + 1")), "1 + 1"),
|
||||
(ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.USER_INPUT, body=" eval 1 + 1")), "1 + 1"),
|
||||
])
|
||||
def test_i_can_eval(ret_val, expected):
|
||||
context = get_context()
|
||||
sheerka = context.sheerka
|
||||
|
||||
prepare_evaluator = PrepareEvalEvaluator()
|
||||
prepare_evaluator.matches(context, ret_val)
|
||||
res = prepare_evaluator.eval(context, ret_val)
|
||||
|
||||
assert len(res) == 2
|
||||
assert res[0].status
|
||||
assert sheerka.isinstance(res[0].body, BuiltinConcepts.USER_INPUT)
|
||||
assert res[0].body.body == expected
|
||||
|
||||
assert res[1].status
|
||||
assert sheerka.isinstance(res[1].body, BuiltinConcepts.CONCEPT_EVAL_REQUESTED)
|
||||
@@ -5,12 +5,13 @@ from core.sheerka import Sheerka, ExecutionContext
|
||||
from core.concept import Concept
|
||||
from evaluators.PythonEvaluator import PythonEvaluator
|
||||
from parsers.PythonParser import PythonNode, PythonParser
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
return ExecutionContext("test", "xxx", sheerka)
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("ret_val, expected", [
|
||||
@@ -39,30 +40,62 @@ def test_i_can_eval(text, expected):
|
||||
assert evaluated.value == expected
|
||||
|
||||
|
||||
def test_i_can_eval_expression_that_references_concepts():
|
||||
@pytest.mark.parametrize("concept", [
|
||||
Concept("foo"),
|
||||
Concept("foo", body="2"),
|
||||
Concept("foo").set_prop("prop", "'a'"),
|
||||
Concept("foo", body="bar")
|
||||
])
|
||||
def test_i_cannot_eval_simple_concept(concept):
|
||||
context = get_context()
|
||||
context.sheerka.add_in_cache(Concept("foo"))
|
||||
|
||||
parsed = PythonParser().parse(context, "foo")
|
||||
evaluated = PythonEvaluator().eval(context, parsed)
|
||||
|
||||
assert evaluated.status
|
||||
assert evaluated.value == Concept("foo").init_key()
|
||||
assert not evaluated.status
|
||||
assert context.sheerka.isinstance(evaluated.value, BuiltinConcepts.NOT_FOR_ME)
|
||||
|
||||
|
||||
def test_i_can_eval_expression_that_references_concepts_with_body():
|
||||
#
|
||||
# def test_i_can_eval_expression_that_references_concepts():
|
||||
# context = get_context()
|
||||
# context.sheerka.add_in_cache(Concept("foo"))
|
||||
#
|
||||
# parsed = PythonParser().parse(context, "foo")
|
||||
# evaluated = PythonEvaluator().eval(context, parsed)
|
||||
#
|
||||
# assert evaluated.status
|
||||
# assert evaluated.value == Concept("foo").init_key()
|
||||
#
|
||||
#
|
||||
# def test_i_can_eval_expression_that_references_concepts_with_body():
|
||||
# """
|
||||
# I can test expression with variables
|
||||
# :return:
|
||||
# """
|
||||
# context = get_context()
|
||||
# context.sheerka.add_in_cache(Concept("foo", body="2"))
|
||||
#
|
||||
# parsed = PythonParser().parse(context, "foo")
|
||||
# evaluated = PythonEvaluator().eval(context, parsed)
|
||||
#
|
||||
# assert evaluated.status
|
||||
# assert evaluated.value == 2
|
||||
|
||||
def test_i_can_eval_expression_with_that_references_concepts():
|
||||
"""
|
||||
I can test expression with variables
|
||||
I can test modules with variables
|
||||
:return:
|
||||
"""
|
||||
context = get_context()
|
||||
context.sheerka.add_in_cache(Concept("foo", body="2"))
|
||||
context.sheerka.add_in_cache(Concept("foo", body=1))
|
||||
|
||||
parsed = PythonParser().parse(context, "foo")
|
||||
parsed = PythonParser().parse(context, "foo + 2")
|
||||
evaluated = PythonEvaluator().eval(context, parsed)
|
||||
|
||||
assert evaluated.status
|
||||
assert evaluated.value == 2
|
||||
assert evaluated.value == 3
|
||||
|
||||
|
||||
def test_i_can_eval_module_with_that_references_concepts():
|
||||
@@ -94,24 +127,24 @@ def test_i_can_eval_module_with_that_references_concepts_with_body():
|
||||
assert evaluated.status
|
||||
assert evaluated.value == 2
|
||||
|
||||
|
||||
def test_i_can_eval_concept_with_props():
|
||||
context = get_context()
|
||||
context.sheerka.add_in_cache(Concept("foo").set_prop("prop", "'a'"))
|
||||
|
||||
parsed = PythonParser().parse(context, "foo")
|
||||
evaluated = PythonEvaluator().eval(context, parsed)
|
||||
|
||||
assert evaluated.status
|
||||
assert evaluated.value == Concept("foo").set_prop("prop", "a").init_key() # evaluated version of foo
|
||||
|
||||
|
||||
def test_i_cannot_eval_when_body_references_unknown_concept():
|
||||
context = get_context()
|
||||
context.sheerka.add_in_cache(Concept("foo", body="bar"))
|
||||
|
||||
parsed = PythonParser().parse(context, "foo")
|
||||
evaluated = PythonEvaluator().eval(context, parsed)
|
||||
|
||||
assert not evaluated.status
|
||||
assert context.sheerka.isinstance(evaluated.value, BuiltinConcepts.ERROR)
|
||||
#
|
||||
# def test_i_can_eval_concept_with_props():
|
||||
# context = get_context()
|
||||
# context.sheerka.add_in_cache(Concept("foo").set_prop("prop", "'a'"))
|
||||
#
|
||||
# parsed = PythonParser().parse(context, "foo")
|
||||
# evaluated = PythonEvaluator().eval(context, parsed)
|
||||
#
|
||||
# assert evaluated.status
|
||||
# assert evaluated.value == Concept("foo").set_prop("prop", "a").init_key() # evaluated version of foo
|
||||
#
|
||||
#
|
||||
# def test_i_cannot_eval_when_body_references_unknown_concept():
|
||||
# context = get_context()
|
||||
# context.sheerka.add_in_cache(Concept("foo", body="bar"))
|
||||
#
|
||||
# parsed = PythonParser().parse(context, "foo")
|
||||
# evaluated = PythonEvaluator().eval(context, parsed)
|
||||
#
|
||||
# assert not evaluated.status
|
||||
# assert context.sheerka.isinstance(evaluated.value, BuiltinConcepts.ERROR)
|
||||
|
||||
@@ -6,12 +6,13 @@ from core.builtin_concepts import ParserResultConcept
|
||||
from core.sheerka import Sheerka, ExecutionContext
|
||||
from core.tokenizer import Tokenizer
|
||||
from parsers.PythonParser import PythonNode, PythonParser, PythonErrorNode
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
return ExecutionContext("test", "xxx", sheerka)
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("text, expected", [
|
||||
|
||||
@@ -0,0 +1,112 @@
|
||||
import pytest
|
||||
|
||||
from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts
|
||||
from core.concept import Concept
|
||||
from core.sheerka import Sheerka, ExecutionContext
|
||||
from evaluators.TooManySuccessEvaluator import TooManySuccessEvaluator
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_context():
|
||||
sheerka = Sheerka(skip_builtins_in_db=True)
|
||||
sheerka.initialize("mem://")
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def r(name, status=True, value=None):
|
||||
value = value or name
|
||||
return ReturnValueConcept(name, status, value)
|
||||
|
||||
|
||||
reduce_requested = ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.REDUCE_REQUESTED))
|
||||
|
||||
|
||||
@pytest.mark.parametrize("return_values, expected", [
|
||||
([r("evaluators.success1"), r("evaluators.success2"), reduce_requested], True),
|
||||
([r("evaluators.success1"), r("evaluators.success2"), r("other"), reduce_requested], True),
|
||||
([r("evaluators.success1"), r("evaluators.success2"), r("other", False), reduce_requested], True),
|
||||
([r("evaluators.a", value=Concept("c1", body="1")),
|
||||
r("evaluators.a", value=Concept("c2", body="1")),
|
||||
r("other"),
|
||||
reduce_requested], True),
|
||||
([r("evaluators.a", value=Concept("c1", body="1")),
|
||||
r("evaluators.a", value=Concept("c2", body="1")),
|
||||
r("parsers.other", False),
|
||||
reduce_requested], True),
|
||||
([r("evaluators.a", value=Concept("c1", body="1")),
|
||||
r("evaluators.a", value=Concept("c2", body="1")),
|
||||
r("parsers.other"),
|
||||
reduce_requested], False),
|
||||
([r("evaluators.success1"), reduce_requested], False),
|
||||
([reduce_requested], False),
|
||||
([r("evaluators.success1"), r("evaluators.success2")], False),
|
||||
])
|
||||
def test_i_can_match(return_values, expected):
|
||||
context = get_context()
|
||||
assert TooManySuccessEvaluator().matches(context, return_values) == expected
|
||||
|
||||
|
||||
def test_i_can_eval():
|
||||
context = get_context()
|
||||
|
||||
value1 = r("evaluators.a", value=Concept("c1", body="1"))
|
||||
value2 = r("evaluators.a", value=Concept("c2", body="2"))
|
||||
return_values = [
|
||||
value1,
|
||||
value2,
|
||||
r("other", False),
|
||||
reduce_requested
|
||||
]
|
||||
|
||||
evaluator = TooManySuccessEvaluator()
|
||||
matches = evaluator.matches(context, return_values)
|
||||
res = evaluator.eval(context, return_values)
|
||||
|
||||
assert matches
|
||||
assert not res.status
|
||||
assert context.sheerka.isinstance(res.body, BuiltinConcepts.TOO_MANY_SUCCESS)
|
||||
assert res.body.body == [value1, value2]
|
||||
assert len(res.parents) == 4
|
||||
|
||||
|
||||
def test_i_can_eval_when_same_success():
|
||||
context = get_context()
|
||||
|
||||
return_values = [
|
||||
r("evaluators.a", value=Concept("c1", body="1")),
|
||||
r("evaluators.a", value=Concept("c2", body="1")),
|
||||
r("other", False),
|
||||
reduce_requested
|
||||
]
|
||||
|
||||
evaluator = TooManySuccessEvaluator()
|
||||
matches = evaluator.matches(context, return_values)
|
||||
res = evaluator.eval(context, return_values)
|
||||
|
||||
assert matches
|
||||
assert res is None
|
||||
|
||||
|
||||
def test_other_success_are_not_reduced():
|
||||
context = get_context()
|
||||
|
||||
value1 = r("evaluators.a", value=Concept("c1", body="1"))
|
||||
value2 = r("evaluators.a", value=Concept("c2", body="2"))
|
||||
other_success = r("other")
|
||||
return_values = [
|
||||
value1,
|
||||
value2,
|
||||
other_success,
|
||||
reduce_requested
|
||||
]
|
||||
|
||||
evaluator = TooManySuccessEvaluator()
|
||||
matches = evaluator.matches(context, return_values)
|
||||
res = evaluator.eval(context, return_values)
|
||||
|
||||
assert matches
|
||||
assert not res.status
|
||||
assert context.sheerka.isinstance(res.body, BuiltinConcepts.TOO_MANY_SUCCESS)
|
||||
assert res.body.body == [value1, value2]
|
||||
assert len(res.parents) == 3
|
||||
assert other_success not in res.parents
|
||||
@@ -5,6 +5,7 @@ import pytest
|
||||
from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts
|
||||
from core.sheerka import Sheerka, ExecutionContext
|
||||
import core.builtin_helpers
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def test_i_can_use_expect_one_when_empty():
|
||||
@@ -160,7 +161,7 @@ def get_sheerka():
|
||||
|
||||
|
||||
def get_context(sheerka):
|
||||
return ExecutionContext("test", "xxx", sheerka)
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def dump_ast(node):
|
||||
|
||||
+24
-21
@@ -9,7 +9,7 @@ from core.sheerka import Sheerka, ExecutionContext
|
||||
from evaluators.MutipleSameSuccessEvaluator import MultipleSameSuccessEvaluator
|
||||
from parsers.ConceptLexerParser import Sequence, ZeroOrMore, StrMatch, OrderedChoice, Optional, ConceptMatch, \
|
||||
ConceptLexerParser
|
||||
from sdp.sheerkaDataProvider import SheerkaDataProvider
|
||||
from sdp.sheerkaDataProvider import SheerkaDataProvider, Event
|
||||
|
||||
tests_root = path.abspath("../build/tests")
|
||||
root_folder = "init_folder"
|
||||
@@ -39,7 +39,7 @@ def get_sheerka(use_dict=True, skip_builtins_in_db=True):
|
||||
|
||||
|
||||
def get_context(sheerka):
|
||||
return ExecutionContext("test", "xxx", sheerka)
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def get_default_concept():
|
||||
@@ -131,8 +131,8 @@ def test_i_cannot_add_the_same_concept_twice():
|
||||
res = sheerka.create_new_concept(get_context(sheerka), concept)
|
||||
|
||||
assert not res.status
|
||||
assert sheerka.isinstance(res.value, BuiltinConcepts.ERROR)
|
||||
assert res.value.body.args[0] == "Duplicate object."
|
||||
assert sheerka.isinstance(res.value, BuiltinConcepts.CONCEPT_ALREADY_DEFINED)
|
||||
assert res.value.body == concept
|
||||
|
||||
|
||||
def test_i_can_get_a_builtin_concept_by_their_enum_or_the_string():
|
||||
@@ -317,33 +317,27 @@ def test_i_cannot_instantiate_when_properties_are_not_recognized():
|
||||
assert sheerka.isinstance(new.concept, concept)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("concept, allow_non_body, expected", [
|
||||
@pytest.mark.parametrize("concept, reduce_simple_list, expected", [
|
||||
(None, False, None),
|
||||
(3.14, False, 3.14),
|
||||
("foo", False, "foo"),
|
||||
(True, False, True),
|
||||
(Concept("name", body="foo"), False, "foo"),
|
||||
(Concept("name"), True, Concept("name")),
|
||||
(ConceptWithGetValue("name").set_prop("my_prop", "my_value"), True, "my_value"),
|
||||
(Concept("name"), False, Concept("name")),
|
||||
(ConceptWithGetValue("name").set_prop("my_prop", "my_value"), False, "my_value"),
|
||||
(ReturnValueConcept(value="return_value"), False, "return_value"),
|
||||
(ReturnValueConcept(value=Concept(key=BuiltinConcepts.USER_INPUT, body="text"), status=True), False, "text"),
|
||||
(ReturnValueConcept(value=UserInputConcept("text"), status=True), False, "text"),
|
||||
(Concept("name", body=["foo", "bar"]), False, ["foo", "bar"]),
|
||||
(Concept("name", body=["foo"]), False, "foo"),
|
||||
(Concept("name", body=["foo"]), True, "foo"),
|
||||
(Concept("name", body=Concept("foo")), False, Concept("foo")),
|
||||
(Concept("name", body=Concept("foo", body="value")), False, "value"),
|
||||
(Concept("name", body=Concept("foo", body=ReturnValueConcept(value="return_value"))), False, "return_value"),
|
||||
])
|
||||
def test_i_can_get_value(concept, allow_non_body, expected):
|
||||
def test_i_can_get_value(concept, reduce_simple_list, expected):
|
||||
sheerka = get_sheerka()
|
||||
|
||||
assert sheerka.value(concept, allow_non_body) == expected
|
||||
|
||||
|
||||
def test_i_cannot_get_value_when_no_body_and_allow_none_body_is_false():
|
||||
sheerka = get_sheerka()
|
||||
concept = Concept("name")
|
||||
allow_none_body = False
|
||||
|
||||
assert sheerka.value(concept, allow_none_body) == sheerka.new(BuiltinConcepts.CANNOT_RESOLVE_VALUE_ERROR,
|
||||
body=concept)
|
||||
assert sheerka.value(concept, reduce_simple_list) == expected
|
||||
|
||||
|
||||
def test_list_of_concept_is_sorted_by_id():
|
||||
@@ -569,6 +563,17 @@ def test_properties_values_takes_precedence_over_the_outside_world():
|
||||
assert evaluated.body == 'concept_b'
|
||||
|
||||
|
||||
def test_properties_values_takes_precedence():
|
||||
sheerka = get_sheerka()
|
||||
sheerka.add_in_cache(Concept(name="a", body="'concept_a'").init_key())
|
||||
sheerka.add_in_cache(Concept(name="b", body="'concept_b'").init_key())
|
||||
|
||||
concept = Concept("foo", body="a + b").set_prop("a", "'prop_a'").init_key()
|
||||
evaluated = sheerka.evaluate_concept(get_context(sheerka), concept)
|
||||
assert evaluated.key == concept.key
|
||||
assert evaluated.body == 'prop_aconcept_b'
|
||||
|
||||
|
||||
def test_i_can_reference_sub_property_of_a_property():
|
||||
sheerka = get_sheerka()
|
||||
sheerka.add_in_cache(Concept(name="concept_a").set_prop("subProp", "'sub_a'").init_key())
|
||||
@@ -666,5 +671,3 @@ def test_i_cannot_add_the_same_concept_twice_in_a_set():
|
||||
all_entries = sheerka.sdp.get("All_" + all_foos.id, None, False)
|
||||
assert len(all_entries) == 1
|
||||
assert foo.id in all_entries
|
||||
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@ from core.builtin_concepts import BuiltinConcepts, SuccessConcept
|
||||
from core.concept import Concept
|
||||
from core.sheerka import Sheerka, ExecutionContext
|
||||
from evaluators.BaseEvaluator import OneReturnValueEvaluator, BaseEvaluator, AllReturnValuesEvaluator
|
||||
from sdp.sheerkaDataProvider import Event
|
||||
|
||||
|
||||
def get_sheerka():
|
||||
@@ -12,7 +13,7 @@ def get_sheerka():
|
||||
|
||||
|
||||
def get_context(sheerka):
|
||||
return ExecutionContext("test", "xxx", sheerka)
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def get_ret_val(sheerka, concept, who="who"):
|
||||
@@ -142,7 +143,7 @@ class EvaluatorOnePreEvaluation(OneReturnValueEvaluatorForTestingPurpose):
|
||||
|
||||
class EvaluatorOneMultiSteps(OneReturnValueEvaluatorForTestingPurpose):
|
||||
def __init__(self):
|
||||
super().__init__("multiStep", [BuiltinConcepts.BEFORE_EVALUATION, BuiltinConcepts.EVALUATION], 10)
|
||||
super().__init__("multiStep", [BuiltinConcepts.EVALUATION, BuiltinConcepts.BEFORE_EVALUATION], 10)
|
||||
|
||||
|
||||
class EvaluatorAllReduceFooBar(EvaluatorAllWithPriority):
|
||||
@@ -321,10 +322,10 @@ def test_evaluation_steps_are_respected():
|
||||
sheerka.evaluators = [EvaluatorOneWithPriority10, EvaluatorOnePreEvaluation]
|
||||
|
||||
entries = [get_ret_val(sheerka, Concept("foo"))]
|
||||
BaseEvaluator.debug_out = []
|
||||
Out.debug_out = []
|
||||
sheerka.execute(get_context(sheerka), entries, [BuiltinConcepts.BEFORE_EVALUATION])
|
||||
|
||||
assert BaseEvaluator.debug_out == [
|
||||
assert Out.debug_out == [
|
||||
'__BEFORE_EVALUATION [0] preEval - matches - target=foo',
|
||||
'__BEFORE_EVALUATION [0] preEval - eval - target=foo',
|
||||
'__BEFORE_EVALUATION [0] preEval - matches - target=__BEFORE_EVALUATION',
|
||||
@@ -336,10 +337,10 @@ def test_evaluation_multi_steps_are_respected():
|
||||
sheerka.evaluators = [EvaluatorOneMultiSteps]
|
||||
|
||||
entries = [get_ret_val(sheerka, Concept("foo"))]
|
||||
BaseEvaluator.debug_out = []
|
||||
Out.debug_out = []
|
||||
sheerka.execute(get_context(sheerka), entries, [BuiltinConcepts.BEFORE_EVALUATION, BuiltinConcepts.EVALUATION])
|
||||
|
||||
assert BaseEvaluator.debug_out == [
|
||||
assert Out.debug_out == [
|
||||
'__BEFORE_EVALUATION [0] multiStep - matches - target=foo',
|
||||
'__BEFORE_EVALUATION [0] multiStep - eval - target=foo',
|
||||
'__BEFORE_EVALUATION [0] multiStep - matches - target=__BEFORE_EVALUATION',
|
||||
@@ -349,3 +350,28 @@ def test_evaluation_multi_steps_are_respected():
|
||||
'__EVALUATION [0] multiStep - matches - target=__EVALUATION',
|
||||
'__EVALUATION [0] multiStep - eval - target=__EVALUATION'
|
||||
]
|
||||
|
||||
|
||||
def test_evaluators_can_be_pre_processed():
|
||||
sheerka = get_sheerka()
|
||||
sheerka.evaluators = [EvaluatorOneModifyFoo]
|
||||
|
||||
entries = [get_ret_val(sheerka, Concept("foo"))]
|
||||
|
||||
# disable evaluator
|
||||
context = get_context(sheerka)
|
||||
context.add_preprocess(EvaluatorOneModifyFoo().name, enabled=False) # disabled for this exec context
|
||||
Out.debug_out = []
|
||||
sheerka.execute(context, entries, [BuiltinConcepts.EVALUATION])
|
||||
assert Out.debug_out == []
|
||||
|
||||
# other contextes are not impacted
|
||||
Out.debug_out = []
|
||||
sheerka.execute(get_context(sheerka), entries, [BuiltinConcepts.EVALUATION])
|
||||
assert Out.debug_out == [
|
||||
'__EVALUATION [0] modifyFoo - matches - target=foo',
|
||||
'__EVALUATION [0] modifyFoo - eval - target=foo',
|
||||
'__EVALUATION [0] modifyFoo - matches - target=__EVALUATION',
|
||||
'__EVALUATION [1] modifyFoo - matches - target=bar',
|
||||
'__EVALUATION [1] modifyFoo - matches - target=__EVALUATION'
|
||||
]
|
||||
|
||||
@@ -9,7 +9,7 @@ from core.sheerka import Sheerka, ExecutionContext
|
||||
from evaluators.MutipleSameSuccessEvaluator import MultipleSameSuccessEvaluator
|
||||
from parsers.ConceptLexerParser import Sequence, ZeroOrMore, StrMatch, OrderedChoice, Optional, ConceptMatch, \
|
||||
ConceptLexerParser
|
||||
from sdp.sheerkaDataProvider import SheerkaDataProvider
|
||||
from sdp.sheerkaDataProvider import SheerkaDataProvider, Event
|
||||
|
||||
tests_root = path.abspath("../build/tests")
|
||||
root_folder = "init_folder"
|
||||
@@ -39,7 +39,7 @@ def get_sheerka(use_dict=True, skip_builtins_in_db=True):
|
||||
|
||||
|
||||
def get_context(sheerka):
|
||||
return ExecutionContext("test", "xxx", sheerka)
|
||||
return ExecutionContext("test", Event(), sheerka)
|
||||
|
||||
|
||||
def get_default_concept():
|
||||
@@ -79,7 +79,7 @@ def test_i_can_eval_concept_with_python_body():
|
||||
res = sheerka.evaluate_user_input(text)
|
||||
assert len(res) == 1
|
||||
assert res[0].status
|
||||
assert res[0].value == 1
|
||||
assert res[0].value == Concept(name="one", body=1).init_key() # by default, the concept is returned
|
||||
|
||||
|
||||
def test_i_can_eval_concept_with_concept_body():
|
||||
@@ -93,7 +93,7 @@ def test_i_can_eval_concept_with_concept_body():
|
||||
return_value = res[0].value
|
||||
assert len(res) == 1
|
||||
assert res[0].status
|
||||
assert sheerka.isinstance(return_value, concept_one)
|
||||
assert return_value == Concept(name="un", body=Concept(name="one").init_key()).init_key()
|
||||
|
||||
|
||||
def test_i_can_eval_concept_with_no_body():
|
||||
@@ -207,23 +207,6 @@ as:
|
||||
assert sheerka.isinstance(res[0].value, BuiltinConcepts.CONCEPT_ALREADY_DEFINED)
|
||||
|
||||
|
||||
# def test_i_can_disable_an_evaluator():
|
||||
# sheerka = get_sheerka()
|
||||
# concept = Concept(name="one", body="1")
|
||||
# sheerka.add_in_cache(concept)
|
||||
#
|
||||
# text = "one"
|
||||
# p = next(e for e in sheerka.evaluators if e.__name__ == "PythonEvaluator")
|
||||
# p.enabled = False # not that you disable the class, not the instance
|
||||
#
|
||||
# res = sheerka.evaluate_user_input(text)
|
||||
# assert len(res) == 1
|
||||
# assert res[0].status
|
||||
# assert sheerka.isinstance(res[0].value, BuiltinConcepts.PARSER_RESULT)
|
||||
#
|
||||
# p.enabled = True # put back for the remaining unit tests
|
||||
|
||||
|
||||
@pytest.mark.parametrize("text", [
|
||||
"",
|
||||
" ",
|
||||
@@ -293,9 +276,9 @@ def test_i_cannot_manage_duplicate_concepts_when_the_values_are_different():
|
||||
|
||||
concepts = res[0].value.body
|
||||
assert len(concepts) == 2
|
||||
sorted_values = sorted(concepts, key=lambda x: x.value)
|
||||
assert sorted_values[0].value == "hello another value"
|
||||
assert sorted_values[1].value == "hello foo"
|
||||
sorted_values = sorted(concepts, key=lambda x: x.value.body)
|
||||
assert sorted_values[0].value.body == "hello another value"
|
||||
assert sorted_values[1].value.body == "hello foo"
|
||||
|
||||
|
||||
def test_i_can_manage_concepts_with_the_same_key_when_values_are_the_same():
|
||||
@@ -308,7 +291,7 @@ def test_i_can_manage_concepts_with_the_same_key_when_values_are_the_same():
|
||||
res = sheerka.evaluate_user_input("hello 'foo'")
|
||||
assert len(res) == 1
|
||||
assert res[0].status
|
||||
assert res[0].value == "hello foo"
|
||||
assert res[0].value.body == "hello foo" # I don't know yet the one to choose
|
||||
assert res[0].who == sheerka.get_evaluator_name(MultipleSameSuccessEvaluator.NAME)
|
||||
|
||||
|
||||
@@ -321,7 +304,7 @@ def test_i_can_create_concepts_with_python_code_as_body():
|
||||
|
||||
assert len(res) == 1
|
||||
assert res[0].status
|
||||
assert isinstance(res[0].value, list)
|
||||
assert isinstance(res[0].value.body, list)
|
||||
|
||||
|
||||
def test_i_can_create_concept_with_bnf_definition():
|
||||
|
||||
Reference in New Issue
Block a user