fixed #18 : I can evaluate concept
This commit is contained in:
@@ -2,7 +2,8 @@ import ast
|
||||
|
||||
import pytest
|
||||
|
||||
from common.ast_utils import NamesWithAttributesVisitor, UnreferencedNamesVisitor, UnreferencedVariablesVisitor
|
||||
from common.ast_utils import NamesWithAttributesVisitor, UnreferencedNamesVisitor, UnreferencedVariablesVisitor, \
|
||||
WhereConstraintVisitor
|
||||
|
||||
|
||||
@pytest.mark.parametrize("source, expected", [
|
||||
@@ -15,9 +16,9 @@ from common.ast_utils import NamesWithAttributesVisitor, UnreferencedNamesVisito
|
||||
("func(x=a, y=b)", {"func", "a", "b"}),
|
||||
|
||||
])
|
||||
def test_i_can_get_unreferenced_names_from_simple_expressions(context, source, expected):
|
||||
def test_i_can_get_unreferenced_names_from_simple_expressions(source, expected):
|
||||
ast_ = ast.parse(source)
|
||||
visitor = UnreferencedNamesVisitor(context)
|
||||
visitor = UnreferencedNamesVisitor()
|
||||
visitor.visit(ast_)
|
||||
|
||||
assert visitor.names == expected
|
||||
@@ -42,9 +43,58 @@ def test_name_with_attribute():
|
||||
("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(context, source, expected):
|
||||
def test_i_can_get_unreferenced_variables_from_simple_expressions(source, expected):
|
||||
ast_ = ast.parse(source)
|
||||
visitor = UnreferencedVariablesVisitor(context)
|
||||
visitor = UnreferencedVariablesVisitor()
|
||||
visitor.visit(ast_)
|
||||
|
||||
assert visitor.names == expected
|
||||
|
||||
|
||||
def test_i_can_get_where_constraints():
|
||||
expr = "a == 2"
|
||||
ast_tree = ast.parse(expr, f"<user input>", 'eval')
|
||||
visitor = WhereConstraintVisitor(ast_tree)
|
||||
|
||||
res = visitor.get_constraints()
|
||||
assert res == {"a": [WhereConstraintVisitor.WhereConstraint("a == 2")]}
|
||||
assert isinstance(res["a"][0].ast_tree, ast.Expression)
|
||||
|
||||
|
||||
def test_i_can_get_where_constraints_when_and():
|
||||
expr = "a == 2 and isinstance(b, Concept)"
|
||||
ast_tree = ast.parse(expr, f"<user input>", 'eval')
|
||||
visitor = WhereConstraintVisitor(ast_tree)
|
||||
|
||||
res = visitor.get_constraints()
|
||||
assert res == {"a": [WhereConstraintVisitor.WhereConstraint("a == 2")],
|
||||
"b": [WhereConstraintVisitor.WhereConstraint("isinstance(b, Concept)")],
|
||||
"Concept": [WhereConstraintVisitor.WhereConstraint("isinstance(b, Concept)")]}
|
||||
|
||||
assert isinstance(res["a"][0].ast_tree, ast.Expression)
|
||||
assert isinstance(res["b"][0].ast_tree, ast.Expression)
|
||||
assert isinstance(res["Concept"][0].ast_tree, ast.Expression)
|
||||
|
||||
|
||||
def test_i_can_get_where_constraint_when_name_is_reference_several_times():
|
||||
expr = "isinstance(a, int) and a == 2"
|
||||
ast_tree = ast.parse(expr, f"<user input>", 'eval')
|
||||
visitor = WhereConstraintVisitor(ast_tree)
|
||||
|
||||
res = visitor.get_constraints()
|
||||
assert res == {"a": [WhereConstraintVisitor.WhereConstraint("isinstance(a, int)"),
|
||||
WhereConstraintVisitor.WhereConstraint("a == 2")],
|
||||
"int": [WhereConstraintVisitor.WhereConstraint("isinstance(a, int)")]}
|
||||
|
||||
assert isinstance(res["a"][0].ast_tree, ast.Expression)
|
||||
assert isinstance(res["a"][1].ast_tree, ast.Expression)
|
||||
assert isinstance(res["int"][0].ast_tree, ast.Expression)
|
||||
|
||||
|
||||
def test_i_cannot_get_constraint_when_or():
|
||||
expr = "isinstance(a, int) or a == 2"
|
||||
ast_tree = ast.parse(expr, f"<user input>", 'eval')
|
||||
visitor = WhereConstraintVisitor(ast_tree)
|
||||
|
||||
with pytest.raises(NotImplementedError):
|
||||
visitor.get_constraints()
|
||||
|
||||
@@ -95,10 +95,10 @@ def test_i_cannot_get_an_attribute_which_is_not_defined():
|
||||
def test_i_can_repr_a_concept():
|
||||
next_id = GetNextId()
|
||||
foo = get_concept("foo", sequence=next_id)
|
||||
assert repr(foo) == "(1001)foo"
|
||||
assert repr(foo) == "(Concept foo#1001)"
|
||||
|
||||
bar = get_concept("bar", pre="is an int", sequence=next_id)
|
||||
assert repr(bar) == "(1002)bar, #pre=is an int"
|
||||
assert repr(bar) == "(Concept bar#1002, #pre=is an int)"
|
||||
|
||||
baz = get_concept("baz", definition="add a b", variables=["a", "b"], sequence=next_id)
|
||||
assert repr(baz) == "(1003)baz, a=**NotInit**, b=**NotInit**"
|
||||
assert repr(baz) == "(Concept baz#1003, a=**NotInit**, b=**NotInit**)"
|
||||
|
||||
@@ -1,6 +1,9 @@
|
||||
from os import path
|
||||
|
||||
import pytest
|
||||
|
||||
from base import UsingFileBasedSheerka
|
||||
from core.concept import ConceptDefaultProps
|
||||
from helpers import get_concept, get_concepts, get_file_content
|
||||
|
||||
|
||||
@@ -34,3 +37,20 @@ class TestSheerka(UsingFileBasedSheerka):
|
||||
assert not sheerka.isinstance(foo, bar.str_id)
|
||||
assert not sheerka.isinstance(foo, bar)
|
||||
assert not sheerka.isinstance(foo, bar.get_metadata())
|
||||
|
||||
@pytest.mark.parametrize("obj, expected", [
|
||||
(None, None),
|
||||
(1, 1),
|
||||
])
|
||||
def test_i_can_get_obj_value(self, sheerka, context, obj, expected):
|
||||
assert sheerka.objvalue(obj) == expected
|
||||
|
||||
def test_i_can_get_obj_value_for_concept(self, sheerka, context):
|
||||
foo = get_concept("foo")
|
||||
bar = get_concept("bar")
|
||||
bar.set_value(ConceptDefaultProps.BODY, 1)
|
||||
foo.set_value(ConceptDefaultProps.BODY, bar)
|
||||
foo.get_runtime_info().is_evaluated = True
|
||||
bar.get_runtime_info().is_evaluated = True
|
||||
|
||||
assert sheerka.objvalue(foo) == 1
|
||||
|
||||
@@ -40,13 +40,14 @@ class TestPythonEvaluator(BaseTest):
|
||||
("a=10\na", 10),
|
||||
])
|
||||
def test_i_can_evaluate_simple_expression(self, sheerka, context, evaluator, text, expected):
|
||||
start = get_parser_input_from(sheerka, context, text)
|
||||
ret = evaluator.eval(context, None, start)
|
||||
assert ret.eaten == [start]
|
||||
assert len(ret.new) == 1
|
||||
assert ret.new[0].status is True
|
||||
assert ret.new[0].value == expected
|
||||
assert ret.new[0].parents == [start]
|
||||
with NewOntology(context, "test_i_can_evaluate_simple_expression"):
|
||||
start = get_parser_input_from(sheerka, context, text)
|
||||
ret = evaluator.eval(context, None, start)
|
||||
assert ret.eaten == [start]
|
||||
assert len(ret.new) == 1
|
||||
assert ret.new[0].status is True
|
||||
assert ret.new[0].value == expected
|
||||
assert ret.new[0].parents == [start]
|
||||
|
||||
def test_i_can_detect_evaluation_error(self, sheerka, context, evaluator):
|
||||
start = get_parser_input_from(sheerka, context, "a")
|
||||
|
||||
+29
-2
@@ -1,9 +1,17 @@
|
||||
from common.global_symbols import NotInit
|
||||
from core.ExecutionContext import ExecutionContext
|
||||
from core.ReturnValue import ReturnValue
|
||||
from core.concept import Concept, ConceptMetadata, DefinitionType
|
||||
from core.concept import Concept, ConceptDefaultProps, ConceptMetadata, DefinitionType
|
||||
from services.SheerkaConceptManager import ConceptManager
|
||||
|
||||
ATTR_MAP = {
|
||||
"where": ConceptDefaultProps.WHERE,
|
||||
"pre": ConceptDefaultProps.PRE,
|
||||
"body": ConceptDefaultProps.BODY,
|
||||
"post": ConceptDefaultProps.POST,
|
||||
"ret": ConceptDefaultProps.RET,
|
||||
}
|
||||
|
||||
|
||||
class GetNextId:
|
||||
def __init__(self):
|
||||
@@ -104,6 +112,25 @@ def get_concept(name=None, body=None,
|
||||
return Concept(metadata)
|
||||
|
||||
|
||||
def get_evaluated_concept(blueprint: Concept | ConceptMetadata, **kwargs):
|
||||
"""
|
||||
Returns a concept where value are already initialized
|
||||
:param blueprint:
|
||||
:type blueprint:
|
||||
:param kwargs:
|
||||
:type kwargs:
|
||||
:return:
|
||||
:rtype:
|
||||
"""
|
||||
res = Concept(blueprint.get_metadata())
|
||||
for k, v in kwargs.items():
|
||||
res.set_value(ATTR_MAP.get(k, k), v)
|
||||
|
||||
res.get_runtime_info().is_evaluated = True
|
||||
|
||||
return res
|
||||
|
||||
|
||||
def get_metadata(name=None, body=None,
|
||||
id=None,
|
||||
key=None,
|
||||
@@ -345,7 +372,7 @@ def define_new_concept(context: ExecutionContext, c: str | Concept | ConceptMeta
|
||||
metadata.parameters)
|
||||
|
||||
assert retval.status
|
||||
concept = sheerka.newn(retval.value.metadata.name)
|
||||
concept = sheerka.newi(retval.value.metadata.id)
|
||||
return concept
|
||||
|
||||
|
||||
|
||||
@@ -1,6 +1,11 @@
|
||||
from base import BaseTest
|
||||
|
||||
|
||||
def get_ret_val(res):
|
||||
assert len(res) == 1
|
||||
return res[0]
|
||||
|
||||
|
||||
class TestNonReg1(BaseTest):
|
||||
|
||||
def test_i_can_evaluate_python(self, sheerka, user):
|
||||
@@ -10,9 +15,16 @@ class TestNonReg1(BaseTest):
|
||||
assert ret_val.status is True
|
||||
assert ret_val.value == 2
|
||||
|
||||
def test_i_can_evaluate_variable_that_is_not_defined(self, sheerka, user):
|
||||
def test_i_cannot_evaluate_variable_that_is_not_defined(self, sheerka, user):
|
||||
res = sheerka.evaluate_user_input("a", user)
|
||||
assert len(res) == 1
|
||||
ret_val = res[0]
|
||||
ret_val = get_ret_val(res)
|
||||
|
||||
assert ret_val.status is False
|
||||
|
||||
def test_i_can_remember_variables(self, sheerka, user):
|
||||
sheerka.evaluate_user_input("a = 10", user)
|
||||
|
||||
res = sheerka.evaluate_user_input("a", user)
|
||||
ret_val = get_ret_val(res)
|
||||
|
||||
assert ret_val.value == 10
|
||||
|
||||
@@ -3,9 +3,11 @@ import pytest
|
||||
from base import BaseTest
|
||||
from common.global_symbols import NotInit
|
||||
from conftest import NewOntology
|
||||
from core.BuiltinConcepts import BuiltinConcepts
|
||||
from core.concept import ConceptDefaultProps
|
||||
from core.error import ErrorContext
|
||||
from core.python_fragment import PythonFragment
|
||||
from helpers import define_new_concept, get_metadata
|
||||
from helpers import define_new_concept, get_concept, get_concepts, get_metadata
|
||||
from services.SheerkaConceptEvaluator import ConceptEvaluator
|
||||
from services.SheerkaPython import EvaluationRef
|
||||
|
||||
@@ -27,7 +29,7 @@ class TestConceptManager(BaseTest):
|
||||
variables=(("a", "1"), ("b", "NotInit"))
|
||||
)
|
||||
|
||||
compiled = service.build(context, metadata)
|
||||
compiled = service._build_attributes(context, metadata)
|
||||
pf = getattr(compiled, ConceptDefaultProps.WHERE)
|
||||
assert isinstance(pf, PythonFragment)
|
||||
assert pf.source_code == metadata.where
|
||||
@@ -59,7 +61,7 @@ class TestConceptManager(BaseTest):
|
||||
def test_i_can_manage_when_no_source_code(self, context, service):
|
||||
metadata = get_metadata(name="foo")
|
||||
|
||||
compiled = service.build(context, metadata)
|
||||
compiled = service._build_attributes(context, metadata)
|
||||
assert getattr(compiled, ConceptDefaultProps.WHERE) is None
|
||||
assert getattr(compiled, ConceptDefaultProps.PRE) is None
|
||||
assert getattr(compiled, ConceptDefaultProps.BODY) is None
|
||||
@@ -72,12 +74,32 @@ class TestConceptManager(BaseTest):
|
||||
body="one + a",
|
||||
variables=(("a", "1"), ("b", "NotInit")))
|
||||
|
||||
compiled = service.build(context, metadata)
|
||||
compiled = service._build_attributes(context, metadata)
|
||||
pf = getattr(compiled, ConceptDefaultProps.BODY)
|
||||
assert isinstance(pf, PythonFragment)
|
||||
assert pf.namespace == {"a": EvaluationRef("self", "a"),
|
||||
"b": EvaluationRef("self", "b")}
|
||||
|
||||
def test_i_can_manage_parsing_errors(self, context, service):
|
||||
metadata = get_metadata(
|
||||
name="foo",
|
||||
where="isinstance(a, int)", # ok
|
||||
body="one + ", # not ok
|
||||
variables=("a",)) # ok
|
||||
|
||||
compiled = service._build_attributes(context, metadata)
|
||||
|
||||
pf = getattr(compiled, ConceptDefaultProps.WHERE)
|
||||
assert isinstance(pf, PythonFragment)
|
||||
assert pf.source_code == metadata.where
|
||||
|
||||
pf = getattr(compiled, "a")
|
||||
assert isinstance(pf, PythonFragment)
|
||||
assert pf.source_code == "NotInit"
|
||||
|
||||
error = getattr(compiled, ConceptDefaultProps.BODY)
|
||||
assert isinstance(error, ErrorContext)
|
||||
|
||||
def test_i_can_eval_concept_attributes(self, context, service):
|
||||
with NewOntology(context, "test_i_can_eval_concept_attributes"):
|
||||
foo_metadata = get_metadata(name="foo",
|
||||
@@ -86,7 +108,7 @@ class TestConceptManager(BaseTest):
|
||||
body="2 + a",
|
||||
post="'post parameter'",
|
||||
ret="self",
|
||||
variables=(("a", "1"), ("b", "NotInit")))
|
||||
variables=(("a", "1"), ("b", "NotInit"), ("c", "1 > 2")))
|
||||
foo = define_new_concept(context, foo_metadata)
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
@@ -94,8 +116,421 @@ class TestConceptManager(BaseTest):
|
||||
assert context.sheerka.isinstance(res, foo)
|
||||
assert res.get_value("a") == 1
|
||||
assert res.get_value("b") == NotInit
|
||||
assert res.get_value("c") is False
|
||||
assert res.get_value(ConceptDefaultProps.WHERE) is True
|
||||
assert res.get_value(ConceptDefaultProps.PRE) is True
|
||||
assert res.get_value(ConceptDefaultProps.BODY) == 3
|
||||
assert res.get_value(ConceptDefaultProps.POST) == "post parameter"
|
||||
assert res.get_value(ConceptDefaultProps.RET) == res
|
||||
|
||||
assert res.get_runtime_info().is_evaluated is True
|
||||
assert res.get_runtime_info().error is None
|
||||
assert ConceptDefaultProps.PRE in res.get_runtime_info().info
|
||||
assert ConceptDefaultProps.WHERE in res.get_runtime_info().info
|
||||
|
||||
def test_i_can_can_evaluate_simple_concept(self, context, service):
|
||||
with NewOntology(context, "test_i_can_eval_concept_attributes"):
|
||||
foo_metadata = get_metadata(name="foo",
|
||||
body="1")
|
||||
foo = define_new_concept(context, foo_metadata)
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
|
||||
assert context.sheerka.isinstance(res, foo)
|
||||
assert res.body == 1
|
||||
assert res.get_runtime_info().is_evaluated is True
|
||||
assert res.get_runtime_info().error is None
|
||||
|
||||
def test_i_cannot_evaluate_an_invalid_concept(self, context, service):
|
||||
with NewOntology(context, "test_i_cannot_evaluate_an_invalid_concept"):
|
||||
foo_metadata = get_metadata(name="foo",
|
||||
where="isinstance(a, int", # ok
|
||||
body="one + ", # not ok
|
||||
variables=("a",))
|
||||
foo = define_new_concept(context, foo_metadata)
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
assert context.sheerka.isinstance(res, BuiltinConcepts.INVALID_CONCEPT)
|
||||
assert ConceptDefaultProps.BODY in res.get_value("reason")
|
||||
assert ConceptDefaultProps.WHERE in res.get_value("reason")
|
||||
|
||||
assert foo.get_runtime_info().is_evaluated is True
|
||||
assert foo.get_runtime_info().error == res
|
||||
|
||||
def test_i_can_manage_runtime_errors(self, context, service):
|
||||
with NewOntology(context, "test_i_can_manage_runtime_errors"):
|
||||
foo_metadata = get_metadata(name="foo",
|
||||
where="isinstance(a, int)", # ok
|
||||
body="one + a", # not ok
|
||||
variables=(("a", "1"),))
|
||||
foo = define_new_concept(context, foo_metadata)
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
assert context.sheerka.isinstance(res, BuiltinConcepts.EVALUATION_ERROR)
|
||||
assert ConceptDefaultProps.BODY in res.get_value("reason")
|
||||
|
||||
assert foo.get_runtime_info().is_evaluated is True
|
||||
assert ConceptDefaultProps.BODY in foo.get_runtime_info().error
|
||||
assert foo.get_runtime_info().error["#body#"].get_error_msg() == "name 'one' is not defined"
|
||||
|
||||
def test_i_do_not_override_initialisation_values_when_i_evaluate(self, context, service):
|
||||
with NewOntology(context, "test_i_do_not_override_initialisation_values_when_i_evaluate"):
|
||||
foo_metadata = get_metadata(name="foo",
|
||||
variables=(("a", "1"), ("b", "'hello world'")))
|
||||
define_new_concept(context, foo_metadata)
|
||||
|
||||
foo_instance = context.sheerka.new("foo", a=42, b="my value")
|
||||
assert foo_instance.a == 42
|
||||
assert foo_instance.b == "my value"
|
||||
|
||||
foo_evaluated = service.evaluate_concept(context, foo_instance)
|
||||
assert foo_evaluated.a == 42
|
||||
assert foo_evaluated.b == "my value"
|
||||
|
||||
def test_i_can_reference_other_concept(self, context, service):
|
||||
with NewOntology(context, "test_i_can_reference_other_concept"):
|
||||
foo, bar = get_concepts(context, "foo", get_concept("bar", body="foo"), use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, bar)
|
||||
assert context.sheerka.isinstance(res, bar)
|
||||
assert bar.body == foo
|
||||
|
||||
def test_i_can_reference_other_concept_with_body(self, context, service):
|
||||
with NewOntology(context, "test_i_can_reference_other_concept_with_body"):
|
||||
foo, bar = get_concepts(context,
|
||||
get_concept("foo", body="1"),
|
||||
get_concept("bar", body="foo"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, bar)
|
||||
assert context.sheerka.isinstance(res, bar)
|
||||
assert context.sheerka.isinstance(bar.body, foo)
|
||||
assert bar.body.body == 1
|
||||
|
||||
def test_i_can_eval_concept_of_concept(self, context, service):
|
||||
with NewOntology(context, "test_i_can_eval_concept_of_concept"):
|
||||
foo, bar, baz, qux = get_concepts(context,
|
||||
get_concept("foo", body="1"),
|
||||
get_concept("bar", body="foo"),
|
||||
get_concept("baz", body="bar"),
|
||||
get_concept("qux", body="baz"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, qux)
|
||||
|
||||
assert context.sheerka.isinstance(res, qux)
|
||||
assert context.sheerka.isinstance(qux.body, baz)
|
||||
assert context.sheerka.isinstance(qux.body.body, bar)
|
||||
assert context.sheerka.isinstance(qux.body.body.body, foo)
|
||||
assert context.sheerka.objvalue(qux) == 1
|
||||
|
||||
def test_concept_variables_precede_global_concepts(self, context, service):
|
||||
with NewOntology(context, "test_concept_variables_precede_global_concepts"):
|
||||
foo, bar, baz = get_concepts(context,
|
||||
get_concept("foo"),
|
||||
get_concept("bar"),
|
||||
get_concept("baz", body="foo", variables=(("foo", "bar"),)),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, baz)
|
||||
|
||||
assert context.sheerka.isinstance(res, baz)
|
||||
assert context.sheerka.isinstance(res.body, bar)
|
||||
|
||||
def test_i_can_evaluate_concept_when_variables_reference_others_concepts_with_body(self, context, service):
|
||||
with NewOntology(context, "test_i_can_evaluate_concept_when_variables_reference_others_concepts_with_body"):
|
||||
foo, bar, baz = get_concepts(context,
|
||||
get_concept("foo", body="1"),
|
||||
get_concept("bar", body="2"),
|
||||
get_concept("baz", body="a + b", variables=(("a", "foo"), ("b", "bar"))),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, baz)
|
||||
|
||||
assert context.sheerka.isinstance(res, baz)
|
||||
assert res.body == 3
|
||||
|
||||
def test_i_can_evaluate_concept_when_variable_is_a_concept_token(self, context, service):
|
||||
with NewOntology(context, "test_i_can_evaluate_concept_when_variable_is_a_concept_token"):
|
||||
foo, bar = get_concepts(context, "foo", get_concept("bar", body="c:foo:"), use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, bar)
|
||||
assert context.sheerka.isinstance(res, bar)
|
||||
assert bar.body == foo
|
||||
|
||||
def test_i_can_evaluate_when_concept_attribute_is_referenced(self, context, service):
|
||||
with NewOntology(context, "test_i_can_evaluate_when_concept_attribute_is_referenced"):
|
||||
foo, bar = get_concepts(context,
|
||||
get_concept("foo", variables=(("var", "'I am var'"),)),
|
||||
get_concept("bar", body="foo.var"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, bar)
|
||||
assert context.sheerka.isinstance(res, bar)
|
||||
assert bar.body == 'I am var'
|
||||
|
||||
@pytest.mark.skip("I cannot parse complex concept")
|
||||
def test_i_can_evaluate_when_body_is_a_complex_concept(self, context, service):
|
||||
with NewOntology(context, "test_i_can_evaluate_concept_when_variable_is_a_concept_token"):
|
||||
add, plus = get_concepts(context,
|
||||
get_concept("add", body="a plus b", variables=("a", "b")),
|
||||
get_concept("plus", body="x + y", variables=("x", "y")),
|
||||
use_sheerka=True)
|
||||
|
||||
add_instance = context.sheerka.new(add, a=1, b=2)
|
||||
add_instance.get_runtime_info().is_evaluated = False # little hack, before
|
||||
|
||||
res = service.evaluate_concept(context, add_instance)
|
||||
assert context.sheerka.isinstance(res, add)
|
||||
assert context.sheerka.isinstance(add_instance.body, plus)
|
||||
assert context.sheerka.objvalue(add_instance) == 3
|
||||
|
||||
@pytest.mark.skip("I cannot parse complex concept")
|
||||
def test_i_can_evaluate_when_body_is_a_complex_concept_and_same_variables_names(self, context, service):
|
||||
with NewOntology(context, "test_i_can_evaluate_when_body_is_a_complex_concept_and_same_variables_names"):
|
||||
add, plus = get_concepts(context,
|
||||
get_concept("add", body="a plus b", variables=("a", "b")),
|
||||
get_concept("plus", body="a + b", variables=("a", "b")),
|
||||
use_sheerka=True)
|
||||
|
||||
add_instance = context.sheerka.new(add, a=1, b=2)
|
||||
|
||||
res = service.evaluate_concept(context, add_instance)
|
||||
assert context.sheerka.isinstance(res, add)
|
||||
assert context.sheerka.isinstance(add_instance.body, plus)
|
||||
assert context.sheerka.objvalue(add_instance) == 3
|
||||
|
||||
def test_body_is_not_evaluated_if_where_clause_failed(self, context, service):
|
||||
foo = get_concept("foo", body="'hello world'", where="False")
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
|
||||
assert context.sheerka.isinstance(res, BuiltinConcepts.EVALUATION_ERROR)
|
||||
assert res.concept.get_value(ConceptDefaultProps.WHERE) is False
|
||||
assert ConceptDefaultProps.WHERE in res.concept.get_runtime_info().error
|
||||
assert res.concept.body is NotInit
|
||||
|
||||
def test_body_is_not_evaluated_if_pre_clause_failed(self, context, service):
|
||||
foo = get_concept("foo", body="'hello world'", pre="False")
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
|
||||
assert context.sheerka.isinstance(res, BuiltinConcepts.EVALUATION_ERROR)
|
||||
assert res.concept.get_value(ConceptDefaultProps.PRE) is False
|
||||
assert ConceptDefaultProps.PRE in res.concept.get_runtime_info().error
|
||||
assert res.concept.body is NotInit
|
||||
|
||||
def test_i_can_evaluate_when_variable_returns_multiple_choices(self, context, service):
|
||||
with NewOntology(context, "test_i_can_evaluate_when_variable_returns_multiple_choices"):
|
||||
one_int, one_str, inc = get_concepts(context,
|
||||
get_concept("one", body="'one'"),
|
||||
get_concept("one", body="1"),
|
||||
get_concept("inc", body="a + 2", variables=(("a", "one"),)),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, inc)
|
||||
|
||||
assert context.sheerka.isinstance(res, inc)
|
||||
assert res.body == 3
|
||||
|
||||
def test_i_can_evaluate_when_variables_refer_to_complex_concept_synonyms(self, context, service):
|
||||
with NewOntology(context, "test_i_can_evaluate_when_variables_refer_to_complex_concept_synonyms"):
|
||||
one_int, one_str, inc = get_concepts(context,
|
||||
get_concept("one", body="'one'"),
|
||||
get_concept("one", body="1"),
|
||||
get_concept("inc", body="a + 2", variables=(("a", "one + 1"),)),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, inc)
|
||||
|
||||
assert context.sheerka.isinstance(res, inc)
|
||||
assert res.body == 4
|
||||
|
||||
def test_i_can_use_where_clause_on_attr_value(self, context, service):
|
||||
with NewOntology(context, "test_i_can_use_where_clause_on_attr_value"):
|
||||
one_2, one_1, foo = get_concepts(context,
|
||||
get_concept("one", body="2"),
|
||||
get_concept("one", body="1"),
|
||||
get_concept("foo",
|
||||
body="a + 2",
|
||||
where="a == 1",
|
||||
variables=(("a", "one"),)),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
|
||||
assert context.sheerka.isinstance(res, foo)
|
||||
assert res.body == 3
|
||||
|
||||
def test_i_can_use_where_clause_on_complex_attr_value(self, context, service):
|
||||
with NewOntology(context, "test_i_can_use_where_clause_on_complex_attr_value"):
|
||||
one_2, one_1, foo = get_concepts(context,
|
||||
get_concept("one", body="2"),
|
||||
get_concept("one", body="1"),
|
||||
get_concept("foo",
|
||||
body="a + 2",
|
||||
where="a == 2",
|
||||
variables=(("a", "one + 1"),)),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
|
||||
assert context.sheerka.isinstance(res, foo)
|
||||
assert res.body == 4
|
||||
|
||||
def test_i_can_use_complex_where_clause(self, context, service):
|
||||
# a 'where' clause with an 'and'
|
||||
with NewOntology(context, "test_i_can_use_multiple_where_clause"):
|
||||
one_2, one_1, two_2, two_1, foo = get_concepts(context,
|
||||
get_concept("one", body="2"),
|
||||
get_concept("one", body="1"),
|
||||
get_concept("two", body="2"),
|
||||
get_concept("two", body="1"),
|
||||
get_concept("foo",
|
||||
body="a + b",
|
||||
where="a == 1 and b == 2",
|
||||
variables=(("a", "one"), ("b", "two"))),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
|
||||
assert context.sheerka.isinstance(res, foo)
|
||||
assert res.body == 3
|
||||
assert ConceptDefaultProps.WHERE in res.get_runtime_info().info
|
||||
|
||||
def test_where_clause_can_use_other_concept(self, context, service):
|
||||
with NewOntology(context, "test_where_clause_can_use_other_concept"):
|
||||
foo1, foo2, true, false = get_concepts(context,
|
||||
get_concept("foo1", where="true", body="'evaluated !'"),
|
||||
get_concept("foo2", where="false", body="'not evaluated !'"),
|
||||
get_concept("true", body="True"),
|
||||
get_concept("false", body="False"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, foo1)
|
||||
assert context.sheerka.isinstance(res, foo1)
|
||||
assert res.body == "evaluated !"
|
||||
|
||||
res = service.evaluate_concept(context, foo2)
|
||||
assert context.sheerka.isinstance(res, BuiltinConcepts.EVALUATION_ERROR)
|
||||
assert res.concept.body is NotInit
|
||||
|
||||
def test_i_can_detect_when_where_clause_failed_on_an_attribute(self, context, service):
|
||||
with NewOntology(context, "test_i_can_detect_when_where_clause_failed_on_an_attribute"):
|
||||
foo, one = get_concepts(context,
|
||||
get_concept("foo", body="a + 1", where="a == 3", variables=(("a", "one"),)),
|
||||
get_concept("one", body="1"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
assert context.sheerka.isinstance(res, BuiltinConcepts.EVALUATION_ERROR)
|
||||
assert context.sheerka.isinstance(res.concept, foo)
|
||||
assert isinstance(res.reason, dict) and "a" in res.reason
|
||||
assert foo.get_runtime_info().is_evaluated
|
||||
|
||||
def test_i_can_use_where_constraint_on_multiple_levels(self, context, service):
|
||||
with NewOntology(context, "test_i_can_use_where_constraint_on_multiple_levels"):
|
||||
foo, bar, baz = get_concepts(context,
|
||||
get_concept("foo", body="True"),
|
||||
get_concept("bar", body="foo"),
|
||||
get_concept("baz", where="bar"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, baz)
|
||||
assert context.sheerka.isinstance(res, "baz")
|
||||
assert ConceptDefaultProps.WHERE in res.get_runtime_info().info
|
||||
|
||||
def test_i_can_use_where_constraint_on_multiple_levels_and_fail(self, context, service):
|
||||
with NewOntology(context, "test_i_can_use_where_constraint_on_multiple_levels_and_fail"):
|
||||
foo, bar, baz = get_concepts(context,
|
||||
get_concept("foo", body="False"),
|
||||
get_concept("bar", body="foo"),
|
||||
get_concept("baz", where="bar"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, baz)
|
||||
assert context.sheerka.isinstance(res, BuiltinConcepts.EVALUATION_ERROR)
|
||||
assert ConceptDefaultProps.WHERE in res.concept.get_runtime_info().error
|
||||
|
||||
def test_i_can_detect_infinite_loop(self, context, service):
|
||||
with NewOntology(context, "test_i_can_detect_infinite_loop"):
|
||||
foo, bar, baz = get_concepts(context,
|
||||
get_concept("foo", body="bar"),
|
||||
get_concept("bar", body="baz"),
|
||||
get_concept("baz", body="foo"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
assert context.sheerka.isinstance(res, BuiltinConcepts.EVALUATION_ERROR)
|
||||
assert context.sheerka.isinstance(res.concept, foo)
|
||||
assert res.reason.ids == [foo.id, bar.id, baz.id]
|
||||
|
||||
def test_i_can_detect_sub_infinite_loop(self, context, service):
|
||||
with NewOntology(context, "test_i_can_detect_sub_infinite_loop"):
|
||||
foo, bar, baz = get_concepts(context,
|
||||
get_concept("foo", body="bar"),
|
||||
get_concept("bar", body="baz"),
|
||||
get_concept("baz", body="bar"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
assert context.sheerka.isinstance(res, BuiltinConcepts.EVALUATION_ERROR)
|
||||
assert context.sheerka.isinstance(res.concept, bar)
|
||||
assert res.reason.ids == [bar.id, baz.id]
|
||||
|
||||
def test_i_can_detect_auto_infinite_loop(self, context, service):
|
||||
with NewOntology(context, "test_i_can_detect_auto_infinite_loop"):
|
||||
foo, = get_concepts(context,
|
||||
get_concept("foo", body="foo"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
assert context.sheerka.isinstance(res, BuiltinConcepts.EVALUATION_ERROR)
|
||||
assert context.sheerka.isinstance(res.concept, foo)
|
||||
assert res.reason.ids == [foo.id]
|
||||
|
||||
def test_i_can_select_the_valid_result_when_multiple_choice_invalid_concept(self, context, service):
|
||||
with NewOntology(context, "test_i_can_select_the_valid_result_when_multiple_choice"):
|
||||
foo, two_ok, two_nok = get_concepts(context,
|
||||
get_concept("foo", body="two"),
|
||||
get_concept("two", body="1 +"), # has to come before the other 'two'
|
||||
get_concept("two", body="1 + 1"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
assert context.sheerka.isinstance(res, foo)
|
||||
assert context.sheerka.objvalue(foo) == 2
|
||||
|
||||
def test_i_can_select_the_valid_result_when_multiple_choice_evaluation_error(self, context, service):
|
||||
with NewOntology(context, "test_i_can_select_the_valid_result_when_multiple_choice"):
|
||||
foo, two_ok, two_nok = get_concepts(context,
|
||||
get_concept("foo", body="two"),
|
||||
get_concept("two", body="1 / 0"), # has to come before the other 'two'
|
||||
get_concept("two", body="1 + 1"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, foo)
|
||||
assert context.sheerka.isinstance(res, foo)
|
||||
assert context.sheerka.objvalue(foo) == 2
|
||||
|
||||
def test_i_can_eval_when_a_return_value_is_defined(self, context, service):
|
||||
with NewOntology(context, "test_i_can_eval_when_a_return_value_is_defined"):
|
||||
foo, bar, baz = get_concepts(context,
|
||||
get_concept("foo"),
|
||||
get_concept("bar"),
|
||||
get_concept("baz", body="foo", ret="bar"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, baz)
|
||||
assert context.sheerka.isinstance(res, bar)
|
||||
assert context.sheerka.isinstance(baz.body, foo)
|
||||
|
||||
def test_i_do_not_use_ret_in_case_of_error(self, context, service):
|
||||
with NewOntology(context, "test_i_do_not_use_ret_in_case_of_error"):
|
||||
foo, baz = get_concepts(context,
|
||||
get_concept("foo"),
|
||||
get_concept("baz", body="foo", ret="bar"),
|
||||
use_sheerka=True)
|
||||
|
||||
res = service.evaluate_concept(context, baz)
|
||||
assert context.sheerka.isinstance(res, BuiltinConcepts.EVALUATION_ERROR)
|
||||
|
||||
@@ -6,8 +6,8 @@ from conftest import NewOntology
|
||||
from core.BuiltinConcepts import BuiltinConcepts
|
||||
from core.concept import ConceptMetadata
|
||||
from core.error import ErrorContext
|
||||
from helpers import get_concepts, get_metadata
|
||||
from services.SheerkaConceptManager import ConceptAlreadyDefined, ConceptManager
|
||||
from helpers import get_metadata
|
||||
|
||||
|
||||
class TestConceptManager(BaseTest):
|
||||
@@ -245,6 +245,16 @@ class TestConceptManager(BaseTest):
|
||||
|
||||
assert service.new((metadata.name, metadata.id)).id == metadata.id
|
||||
|
||||
def test_i_can_instantiate_a_list_of_concepts(self, context, service):
|
||||
with NewOntology(context, "test_i_can_instantiate_a_list_of_concepts"):
|
||||
foo, bar = get_concepts(context, "foo", "bar", use_sheerka=True)
|
||||
|
||||
res = service.new([foo.get_metadata(), bar.get_metadata()])
|
||||
|
||||
assert len(res) == 2
|
||||
assert context.sheerka.isinstance(res[0], foo)
|
||||
assert context.sheerka.isinstance(res[1], bar)
|
||||
|
||||
def test_unknown_concept_is_return_if_the_identifier_is_not_found(self, service):
|
||||
assert service.new("unknown").name == BuiltinConcepts.UNKNOWN_CONCEPT
|
||||
|
||||
|
||||
@@ -2,74 +2,20 @@ import pytest
|
||||
|
||||
from base import BaseTest, DummyObj
|
||||
from caching.FastCache import FastCache
|
||||
from core.ExecutionContext import ContextActions
|
||||
from common.global_symbols import NotFound
|
||||
from core.Event import Event
|
||||
from core.ExecutionContext import ContextActions, ExecutionContext
|
||||
from services.SheerkaMemory import SheerkaMemory
|
||||
|
||||
|
||||
class TestSheerkaEngine(BaseTest):
|
||||
@pytest.fixture()
|
||||
def service(self, sheerka):
|
||||
return SheerkaMemory(sheerka) # I want a new instance to keep Sheerka clean (when I update stm)
|
||||
return sheerka.services[SheerkaMemory.NAME]
|
||||
|
||||
def test_i_can_add_to_global_short_term_memory(self, service):
|
||||
dummy = DummyObj()
|
||||
service.add_to_short_term_memory(None, "a", dummy)
|
||||
service.add_to_short_term_memory("a", dummy)
|
||||
|
||||
assert service.short_term_objects.copy() == {'global': {'a': dummy}}
|
||||
|
||||
def test_i_can_add_and_get_stm_data(self, context, service):
|
||||
sub_context = context.push("TestSheerkaEngine", ContextActions.TESTING, None)
|
||||
|
||||
service.add_to_short_term_memory(None, "a", "global level")
|
||||
service.add_to_short_term_memory(context, "a", "context level")
|
||||
service.add_to_short_term_memory(sub_context, "a", "sub context level")
|
||||
|
||||
assert service.get_from_short_term_memory(sub_context, "a") == "sub context level"
|
||||
assert service.get_from_short_term_memory(context, "a") == "context level"
|
||||
assert service.get_from_short_term_memory(None, "a") == "global level"
|
||||
|
||||
def test_i_can_list_stm_data(self, context, service):
|
||||
sub_context = context.push("TestSheerkaEngine", ContextActions.TESTING, None)
|
||||
|
||||
service.add_to_short_term_memory(None, "a", "global a")
|
||||
service.add_to_short_term_memory(None, "b", "global b")
|
||||
service.add_to_short_term_memory(context, "a", "context a")
|
||||
service.add_to_short_term_memory(context, "c", "context c")
|
||||
service.add_to_short_term_memory(sub_context, "d", "sub context d")
|
||||
service.add_to_short_term_memory(sub_context, "a", "sub context a")
|
||||
|
||||
assert service.list_short_term_memory(sub_context) == {"a": "sub context a",
|
||||
"b": "global b",
|
||||
"c": "context c",
|
||||
"d": "sub context d"}
|
||||
|
||||
assert service.list_short_term_memory(context) == {"a": "context a",
|
||||
"b": "global b",
|
||||
"c": "context c"}
|
||||
|
||||
assert service.list_short_term_memory(None) == {"a": "global a",
|
||||
"b": "global b"}
|
||||
|
||||
def test_i_can_list_stm_data_when_context_have_no_entry(self, context, service):
|
||||
sub_context = context.push("TestSheerkaEngine", ContextActions.TESTING, None)
|
||||
|
||||
service.add_to_short_term_memory(sub_context, "d", "sub context d")
|
||||
service.add_to_short_term_memory(sub_context, "a", "sub context a")
|
||||
|
||||
assert service.list_short_term_memory(sub_context) == {"a": "sub context a", "d": "sub context d"}
|
||||
assert service.list_short_term_memory(context) == {}
|
||||
assert service.list_short_term_memory(None) == {}
|
||||
|
||||
def test_i_value_are_removed_when_cache_is_full(self, context, service):
|
||||
service.short_term_objects = FastCache(3)
|
||||
context1 = context.push("TestSheerkaEngine", ContextActions.TESTING, None)
|
||||
context2 = context.push("TestSheerkaEngine", ContextActions.TESTING, None)
|
||||
context3 = context.push("TestSheerkaEngine", ContextActions.TESTING, None)
|
||||
|
||||
service.add_to_short_term_memory(context, "a", "context")
|
||||
service.add_to_short_term_memory(context1, "b", "context 1")
|
||||
service.add_to_short_term_memory(context2, "c", "context 2")
|
||||
assert context.id in service.short_term_objects
|
||||
|
||||
service.add_to_short_term_memory(context3, "d", "context 3")
|
||||
assert context.id not in service.short_term_objects
|
||||
assert service.get_from_short_term_memory("a") == dummy
|
||||
assert service.sheerka.om.current_ontology().fast_cache.copy() == {'a': dummy}
|
||||
|
||||
@@ -4,10 +4,14 @@ from base import BaseTest, DummyObj
|
||||
from common.global_symbols import NoFirstToken, NotFound, NotInit, Removed
|
||||
from conftest import NewOntology
|
||||
from core.BuiltinConcepts import BuiltinConcepts
|
||||
from core.ExecutionContext import ContextActions
|
||||
from core.concept import ConceptDefaultProps
|
||||
from core.error import MethodAccessError
|
||||
from evaluators.PythonParser import PythonParser
|
||||
from helpers import _rv, define_new_concept, get_concepts, get_metadata
|
||||
from helpers import _rv, define_new_concept, get_concepts, get_evaluated_concept, get_metadata
|
||||
from parsers.ParserInput import ParserInput
|
||||
from services.SheerkaPython import EvaluationRef, SheerkaPython
|
||||
from parsers.tokenizer import Token, TokenKind
|
||||
from services.SheerkaPython import EvalMethod, EvaluationContext, EvaluationRef, Expando, MultipleResults, SheerkaPython
|
||||
|
||||
|
||||
def get_python_fragment(sheerka, context, command):
|
||||
@@ -34,52 +38,53 @@ class TestSheerkaPython(BaseTest):
|
||||
("NoFirstToken", NoFirstToken),
|
||||
])
|
||||
def test_i_can_evaluate_simple_expression(self, sheerka, context, service, text, expected):
|
||||
python_fragment = get_python_fragment(sheerka, context, text)
|
||||
ret = service.evaluate_python(context, python_fragment)
|
||||
assert ret == expected
|
||||
with NewOntology(context, "test_i_can_evaluate_simple_expression"):
|
||||
python_fragment = get_python_fragment(sheerka, context, text)
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
assert ret == expected
|
||||
|
||||
def test_i_can_eval_isinstance_for_type(self, sheerka, context, service):
|
||||
def test_i_can_eval_isinstance_with_a_type(self, sheerka, context, service):
|
||||
python_fragment = get_python_fragment(sheerka, context, "isinstance('some string', str)")
|
||||
ret = service.evaluate_python(context, python_fragment)
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
|
||||
assert ret is True
|
||||
|
||||
def test_i_can_eval_isinstance_for_concept(self, sheerka, context, service):
|
||||
def test_i_can_eval_isinstance_with_a_concept(self, sheerka, context, service):
|
||||
with NewOntology(context, "test_i_can_eval_isinstance_for_concept"):
|
||||
get_concepts(context, "foo", use_sheerka=True)
|
||||
python_fragment = get_python_fragment(sheerka, context, "isinstance(foo, 'foo')")
|
||||
ret = service.evaluate_python(context, python_fragment)
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
assert ret is True
|
||||
|
||||
# 'foo' is also a Concept
|
||||
python_fragment = get_python_fragment(sheerka, context, "isinstance(foo, Concept)")
|
||||
ret = service.evaluate_python(context, python_fragment)
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
assert ret is True
|
||||
|
||||
def test_i_can_use_value_from_global_namespace(self, sheerka, context, service):
|
||||
python_fragment = get_python_fragment(sheerka, context, "self.a")
|
||||
|
||||
ret = service.evaluate_python(context, python_fragment, {"self": DummyObj("my dummy value")})
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment,
|
||||
{"self": DummyObj("my dummy value")})
|
||||
assert ret == "my dummy value"
|
||||
|
||||
def test_i_can_eval_using_eval_ref(self, sheerka, context, service):
|
||||
python_fragment = get_python_fragment(sheerka, context, "a")
|
||||
python_fragment.namespace = {"a": EvaluationRef("self", "a")}
|
||||
|
||||
ret = service.evaluate_python(context, python_fragment, {"self": DummyObj("my dummy value")})
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment,
|
||||
{"self": DummyObj("my dummy value")})
|
||||
assert ret == "my dummy value"
|
||||
|
||||
@pytest.mark.skip("Concept evaluation is not implemented")
|
||||
def test_i_can_eval_concept_properties(self, sheerka, context, service):
|
||||
with NewOntology(context, "test_i_can_eval_concept_properties"):
|
||||
foo_meta = get_metadata("foo", variables=[("a", "hello world")])
|
||||
foo_meta = get_metadata("foo", variables=[("a", "'hello world'")])
|
||||
define_new_concept(context, foo_meta)
|
||||
|
||||
python_fragment = get_python_fragment(sheerka, context, "foo.a")
|
||||
ret = service.evaluate_python(context, python_fragment)
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
assert ret == "hello world"
|
||||
|
||||
@pytest.mark.skip("Concept evaluation is not implemented")
|
||||
def test_i_can_eval_python_mixed_with_concept(self, sheerka, context, service):
|
||||
with NewOntology(context, "test_i_can_eval_python_mixed_with_concept"):
|
||||
foo_meta = get_metadata("foo", variables=[("a", "1")])
|
||||
@@ -87,41 +92,249 @@ class TestSheerkaPython(BaseTest):
|
||||
get_concepts(context, foo_meta, bar_meta, use_sheerka=True)
|
||||
|
||||
python_fragment = get_python_fragment(sheerka, context, "bar + foo.a")
|
||||
ret = service.evaluate_python(context, python_fragment)
|
||||
assert ret == "3"
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
assert ret == 3
|
||||
|
||||
def test_i_can_remember_previous_results(self, sheerka, context, service):
|
||||
python_fragment = get_python_fragment(sheerka, context, "a=10")
|
||||
ret = service.evaluate_python(context, python_fragment)
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
assert ret is None
|
||||
|
||||
python_fragment = get_python_fragment(sheerka, context, "a")
|
||||
ret = service.evaluate_python(context, python_fragment)
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
assert ret == 10
|
||||
|
||||
def test_i_can_import_module(self, sheerka, context, service):
|
||||
python_fragment = get_python_fragment(sheerka, context, "import math")
|
||||
ret = service.evaluate_python(context, python_fragment)
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
assert ret is None
|
||||
|
||||
python_fragment = get_python_fragment(sheerka, context, "math.sqrt(4)")
|
||||
ret = service.evaluate_python(context, python_fragment)
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
assert ret == 2
|
||||
|
||||
def test_i_can_import_function_from_module(self, sheerka, context, service):
|
||||
python_fragment = get_python_fragment(sheerka, context, "from math import sqrt")
|
||||
ret = service.evaluate_python(context, python_fragment)
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
assert ret is None
|
||||
|
||||
python_fragment = get_python_fragment(sheerka, context, "sqrt(4)")
|
||||
ret = service.evaluate_python(context, python_fragment)
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
assert ret == 2
|
||||
|
||||
def test_i_can_eval_when_context_is_needed(self, sheerka, context, service):
|
||||
with NewOntology(context, "test_i_can_eval_when_context_is_needed"):
|
||||
python_fragment = get_python_fragment(sheerka, context, "define_new_concept('foo')")
|
||||
ret = service.evaluate_python(context, python_fragment)
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
assert sheerka.isinstance(ret.value, BuiltinConcepts.NEW_CONCEPT)
|
||||
# for info, there are two level of value
|
||||
# one for PythonEvaluator return value
|
||||
# one for the ConceptManager return value
|
||||
|
||||
def test_i_can_return_multiple_results(self, sheerka, context, service):
|
||||
with NewOntology(context, "test_i_can_return_multiple_values"):
|
||||
foo_1, foo_2, foo_3 = get_concepts(context,
|
||||
get_metadata("foo", body="'foo'"),
|
||||
get_metadata("foo", body="True"),
|
||||
get_metadata("foo", body="'bar'"),
|
||||
use_sheerka=True)
|
||||
|
||||
python_fragment = get_python_fragment(sheerka, context, "foo")
|
||||
|
||||
evaluation_context = EvaluationContext(eval_method=EvalMethod.All)
|
||||
ret = service.evaluate_python(context, evaluation_context, python_fragment)
|
||||
|
||||
assert ret == MultipleResults(get_evaluated_concept(foo_1, body='foo'),
|
||||
"foo",
|
||||
get_evaluated_concept(foo_2, body=True),
|
||||
True,
|
||||
get_evaluated_concept(foo_3, body='bar'),
|
||||
"bar")
|
||||
|
||||
def test_i_can_eval_when_multiple_concepts(self, sheerka, context, service):
|
||||
with NewOntology(context, "test_i_can_eval_when_multiple_concepts"):
|
||||
get_concepts(context,
|
||||
get_metadata("one", body="'one'"),
|
||||
get_metadata("one", body="1"),
|
||||
use_sheerka=True)
|
||||
python_fragment = get_python_fragment(sheerka, context, "one + 1")
|
||||
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
|
||||
assert ret == 2
|
||||
|
||||
def test_i_can_eval_until_a_successful_result_is_found(self, sheerka, context, service):
|
||||
with NewOntology(context, "test_i_can_eval_when_multiple_concepts"):
|
||||
get_concepts(context,
|
||||
get_metadata("one", body="'one'"),
|
||||
get_metadata("one", body="1"),
|
||||
get_metadata("one", body="2"),
|
||||
use_sheerka=True)
|
||||
python_fragment = get_python_fragment(sheerka, context, "one + 1")
|
||||
service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
|
||||
# check the number of evaluated namespaces
|
||||
# there are 3 concepts, so there must be 6 results
|
||||
# But we stop after the second 'one' concept
|
||||
ec = next(filter(lambda _ec: _ec.action == ContextActions.EVALUATING_PYTHON, context.get_children()))
|
||||
assert len(ec.values["all_results"]) == 4
|
||||
|
||||
def test_i_can_eval_all_namespaces(self, sheerka, context, service):
|
||||
with NewOntology(context, "test_i_can_return_multiple_values"):
|
||||
foo_1, foo_2, foo_3 = get_concepts(context,
|
||||
get_metadata("foo", body="'foo'"),
|
||||
get_metadata("foo", body="True"),
|
||||
get_metadata("foo", body="'bar'"),
|
||||
use_sheerka=True)
|
||||
|
||||
python_fragment = get_python_fragment(sheerka, context, "foo")
|
||||
|
||||
evaluation_context = EvaluationContext(eval_method=EvalMethod.All)
|
||||
service.evaluate_python(context, evaluation_context, python_fragment)
|
||||
|
||||
# check the number of evaluated namespaces
|
||||
ec = next(filter(lambda _ec: _ec.action == ContextActions.EVALUATING_PYTHON, context.get_children()))
|
||||
assert len(ec.values["all_results"]) == 6
|
||||
|
||||
def test_i_can_eval_until_true(self, sheerka, context, service):
|
||||
with NewOntology(context, "test_i_can_return_multiple_values"):
|
||||
get_concepts(context,
|
||||
get_metadata("foo", body="False"),
|
||||
get_metadata("foo", body="True"),
|
||||
get_metadata("foo", body="'bar'"),
|
||||
use_sheerka=True)
|
||||
|
||||
python_fragment = get_python_fragment(sheerka, context, "foo")
|
||||
|
||||
evaluation_context = EvaluationContext(eval_method=EvalMethod.UntilTrue)
|
||||
res = service.evaluate_python(context, evaluation_context, python_fragment)
|
||||
|
||||
assert res is True
|
||||
|
||||
# check the number of evaluated namespaces
|
||||
# We stop after the second 'one' concept, so only 4 results
|
||||
ec = next(filter(lambda _ec: _ec.action == ContextActions.EVALUATING_PYTHON, context.get_children()))
|
||||
assert len(ec.values["all_results"]) == 4
|
||||
|
||||
def test_eval_until_success_return_false_if_true_is_not_found(self, sheerka, context, service):
|
||||
with NewOntology(context, "test_i_can_return_multiple_values"):
|
||||
get_concepts(context,
|
||||
get_metadata("foo", body="False"),
|
||||
get_metadata("foo", body="'bar'"),
|
||||
use_sheerka=True)
|
||||
|
||||
python_fragment = get_python_fragment(sheerka, context, "foo")
|
||||
|
||||
evaluation_context = EvaluationContext(eval_method=EvalMethod.UntilTrue)
|
||||
ret = service.evaluate_python(context, evaluation_context, python_fragment)
|
||||
|
||||
assert ret is False
|
||||
|
||||
def test_i_can_return_empty_list(self, sheerka, context, service):
|
||||
python_fragment = get_python_fragment(sheerka, context, "[]")
|
||||
ret = service.evaluate_python(context, EvaluationContext(), python_fragment)
|
||||
|
||||
assert ret == []
|
||||
|
||||
def test_can_create_namespaces(self, context, service):
|
||||
with NewOntology(context, "test_i_can_eval_when_context_is_needed"):
|
||||
namespace = service.create_namespace(context, ['in_context'], None, {}, {}, False)
|
||||
assert namespace == {"in_context": context.in_context}
|
||||
|
||||
namespace = service.create_namespace(context, ['isinstance'], None, {}, {}, False)
|
||||
assert namespace == {"isinstance": context.sheerka.extended_isinstance}
|
||||
|
||||
namespace = service.create_namespace(context, ['print'], None, {}, {}, False)
|
||||
assert namespace == {"print": print}
|
||||
|
||||
namespace = service.create_namespace(context, ['print'], None, {}, {}, True)
|
||||
assert namespace == {} # print method has side effect, so it's excluded
|
||||
|
||||
# ###################
|
||||
# sheerka expando
|
||||
# ###################
|
||||
namespace = service.create_namespace(context, ['sheerka'], set(), {}, {}, False)
|
||||
assert isinstance(namespace["sheerka"], Expando)
|
||||
assert len(vars(namespace["sheerka"])) == 1 # 'expando_name' only
|
||||
|
||||
namespace = service.create_namespace(context, ['sheerka'], {"new", "echo"}, {}, {}, False)
|
||||
assert isinstance(namespace["sheerka"], Expando)
|
||||
assert len(vars(namespace["sheerka"])) == 3 # 'expando_name' + new() + echo()
|
||||
|
||||
with pytest.raises(MethodAccessError):
|
||||
# new method is not allowed if expression_only is True
|
||||
service.create_namespace(context, ['sheerka'], {"new", "echo"}, {}, {}, True)
|
||||
|
||||
# ###################
|
||||
# sheerka methods
|
||||
# ###################
|
||||
namespace = service.create_namespace(context, ['new'], None, {}, {}, False)
|
||||
assert namespace == {"new": context.sheerka.new} # Sheerka methods are not set
|
||||
|
||||
with pytest.raises(MethodAccessError):
|
||||
# new method is not allowed if expression_only is True
|
||||
service.create_namespace(context, ['new'], None, {}, {}, True)
|
||||
|
||||
# ###################
|
||||
context.sheerka.add_to_short_term_memory("key", "short term memory value")
|
||||
namespace = service.create_namespace(context, ['key'], None, {}, {}, False)
|
||||
assert namespace == {"key": "short term memory value"}
|
||||
|
||||
foo = define_new_concept(context, get_metadata("foo", body="1"))
|
||||
foo_token = Token(TokenKind.CONCEPT, ("foo", None), 0, 1, 1)
|
||||
namespace = service.create_namespace(context, ['foo'], None, {"foo": foo_token}, {}, False)
|
||||
assert context.sheerka.isinstance(namespace["foo"], foo)
|
||||
assert namespace["foo"].body == 1 # local namespace are evaluated
|
||||
|
||||
namespace = service.create_namespace(context, ['foo'], None, {}, {"foo": foo}, False)
|
||||
assert context.sheerka.isinstance(namespace["foo"], foo)
|
||||
assert namespace["foo"].body is NotInit # global namespace are used as is
|
||||
|
||||
namespace = service.create_namespace(context, ['foo'], None, {}, {}, False)
|
||||
assert context.sheerka.isinstance(namespace["foo"], foo)
|
||||
assert namespace["foo"].body == 1 # concept instantiation are evaluated
|
||||
|
||||
def test_i_can_manage_concept_synonyms(self, context, service):
|
||||
foo, bar, baz = get_concepts(context, "foo", "bar", "baz", use_sheerka=False)
|
||||
# foo, bar and baz are supposed to be concept synonyms
|
||||
namespace = {"a": "value a",
|
||||
"foo": MultipleResults(foo, bar, baz),
|
||||
"b": "value b",
|
||||
"bar": MultipleResults(baz, bar)}
|
||||
|
||||
res = service.manage_multiple_choices(namespace)
|
||||
|
||||
assert len(res) == 6
|
||||
assert res[0] == {"a": "value a", "b": "value b", "foo": foo, "bar": baz}
|
||||
assert res[1] == {"a": "value a", "b": "value b", "foo": foo, "bar": bar}
|
||||
assert res[2] == {"a": "value a", "b": "value b", "foo": bar, "bar": baz}
|
||||
assert res[3] == {"a": "value a", "b": "value b", "foo": bar, "bar": bar}
|
||||
assert res[4] == {"a": "value a", "b": "value b", "foo": baz, "bar": baz}
|
||||
assert res[5] == {"a": "value a", "b": "value b", "foo": baz, "bar": bar}
|
||||
|
||||
def test_i_can_manage_namespaces_when_concepts_have_values(self, context, service):
|
||||
foo, bar, baz = get_concepts(context, "foo", "bar", "baz", use_sheerka=False)
|
||||
foo.set_value(ConceptDefaultProps.BODY, "foo value")
|
||||
foo.get_runtime_info().is_evaluated = True
|
||||
bar.set_value(ConceptDefaultProps.BODY, "bar value")
|
||||
bar.get_runtime_info().is_evaluated = True
|
||||
|
||||
namespaces = [
|
||||
{"a": "value a", "foo": foo, "baz": baz},
|
||||
{"a": "value a", "foo": bar, "baz": baz},
|
||||
]
|
||||
|
||||
res = service.manage_concepts_with_body(context, namespaces)
|
||||
|
||||
assert len(res) == 4
|
||||
assert res == [
|
||||
{"a": "value a", "baz": baz, "foo": foo},
|
||||
{"a": "value a", "baz": baz, "foo": "foo value"},
|
||||
{"a": "value a", "baz": baz, "foo": bar},
|
||||
{"a": "value a", "baz": baz, "foo": "bar value"},
|
||||
]
|
||||
|
||||
def test_multiple_results_concept_only_return_concepts(self, context):
|
||||
foo, bar = get_concepts(context, "foo", "bar")
|
||||
assert MultipleResults(foo, "one", bar, 1).concepts_only() == MultipleResults(foo, bar)
|
||||
assert MultipleResults("one", 1).concepts_only() == MultipleResults()
|
||||
|
||||
+22
-2
@@ -1,8 +1,8 @@
|
||||
import pytest
|
||||
|
||||
from common.global_symbols import NotInit
|
||||
from core.concept import Concept, ConceptMetadata, DefinitionType
|
||||
from helpers import GetNextId, get_concept, get_concepts, get_metadata, get_metadatas
|
||||
from core.concept import Concept, ConceptDefaultProps, ConceptMetadata, DefinitionType
|
||||
from helpers import GetNextId, get_concept, get_concepts, get_metadata, get_metadatas, get_evaluated_concept
|
||||
|
||||
|
||||
def test_i_can_get_default_value_when_get_metadata():
|
||||
@@ -221,3 +221,23 @@ def test_i_can_get_multiple_concepts_using_sheerka(sheerka, context):
|
||||
assert baz2.id == "1003"
|
||||
assert baz2.key == "baz __var__0"
|
||||
assert baz2.get_value("var1") == "value for var1"
|
||||
|
||||
|
||||
def test_i_can_get_multiple_concepts_when_same_name(sheerka, context):
|
||||
one_str, one_int = get_concepts(context,
|
||||
get_metadata("one", body="'one'"),
|
||||
get_metadata("one", body="1"),
|
||||
use_sheerka=True)
|
||||
|
||||
assert sheerka.isinstance(one_str, "one")
|
||||
assert sheerka.isinstance(one_int, "one")
|
||||
|
||||
|
||||
def test_i_can_create_test_concept(sheerka, context):
|
||||
concept = get_concept("one", body="'one'")
|
||||
|
||||
test_concept = get_evaluated_concept(concept, body='hello', a="value for a")
|
||||
|
||||
assert test_concept.get_metadata() == concept.get_metadata()
|
||||
assert test_concept.get_value(ConceptDefaultProps.BODY) == "hello"
|
||||
assert test_concept.get_value("a") == "value for a"
|
||||
|
||||
Reference in New Issue
Block a user