def test_atom_formatting():
f = formatting.TermFormatter(Engine(), quoted=False, ignore_ops=False)
t = parse_query_term("'abc def'.")
assert f.format(t) == "abc def"
f = formatting.TermFormatter(Engine(), quoted=True, ignore_ops=False)
t = parse_query_term("'abc def'.")
assert f.format(t) == "'abc def'"
t = parse_query_term("abc.")
assert f.format(t) == "abc"
def test_copy():
e = Engine()
m = e.modulewrapper
l1 = Rule(
C('a'), C('a1'), m.user_module,
Rule(C('b'), C('b1'), m.user_module,
Rule(C('c'), C('c1'), m.user_module)))
l1c, _ = l1.copy()
t1 = l1
t2 = l1c
while t1 is not None:
assert t1 is not t2
assert t1 == t2
t1 = t1.next
t2 = t2.next
l0 = Rule(
C(-1), C('a'), m.user_module,
Rule(C(-2), C('b'), m.user_module,
Rule(C(-3), C('c'), m.user_module, l1)))
l0c, end = l0.copy(l1)
t1 = l0
t2 = l0c
while t1 is not l1:
assert t1 == t2
assert t1 is not t2
t1 = t1.next
prev = t2
t2 = t2.next
assert t2 is l1
assert prev is end
def test_function():
e = Engine()
m = e.modulewrapper
def get_rules(chain):
r = []
while chain:
r.append((chain.head, chain.body))
chain = chain.next
return r
f = Function()
r1 = Rule(C(1), C(2), m.user_module)
r2 = Rule(C(2), C(3), m.user_module)
r3 = Rule(C(0), C(0), m.user_module)
r4 = Rule(C(15), C(-1), m.user_module)
f.add_rule(r1, True)
assert get_rules(f.rulechain) == [(C(1), C(2))]
f.add_rule(r2, True)
assert get_rules(f.rulechain) == [(C(1), C(2)), (C(2), C(3))]
f.add_rule(r3, False)
assert get_rules(f.rulechain) == [(C(0), C(0)), (C(1), C(2)), (C(2), C(3))]
# test logical update view
rulechain = f.rulechain
f.add_rule(r4, True)
assert get_rules(rulechain) == [(C(0), C(0)), (C(1), C(2)), (C(2), C(3))]
assert get_rules(f.rulechain) == [(C(0), C(0)), (C(1), C(2)), (C(2), C(3)),
(C(15), C(-1))]
def test_atom_concat():
assert_true("atom_concat(ab, cdef, abcdef).")
assert_true("atom_concat(ab, cdef, X), X = abcdef.")
assert_true("atom_concat(ab, X, abcdef), X = cdef.")
assert_true("atom_concat(X, cdef, abcdef), X = ab.")
assert_true("atom_concat(1, Y, '1def'), Y = def.")
heaps = collect_all(Engine(), "atom_concat(X, Y, abcd), atom(X), atom(Y).")
assert len(heaps) == 5
def test_op_formatting():
f = formatting.TermFormatter(Engine(), quoted=False, ignore_ops=False)
t = parse_query_term("'+'(1, 2).")
assert f.format(t) == "1+2"
t = parse_query_term("'+'(1, *(3, 2)).")
assert f.format(t) == "1+3*2"
t = parse_query_term("'*'(1, *(3, 2)).")
assert f.format(t) == "1*(3*2)"
def test_repeat():
assert_true("repeat, true.")
e = Engine()
assert_false("repeat, !, fail.")
# hard to test repeat differently
e = get_engine('f :- repeat, !, fail.')
assert_false('f.', e)
assert_true('f; true.', e)
def assert_true(query, e=None):
if e is None:
e = Engine()
terms, vars = e.parse(query)
term, = terms
e.run_query_in_current(term)
return dict([(name, var.dereference(None))
for name, var in vars.iteritems()])
def test_between():
assert_true("between(12, 15, 12).")
assert_true("between(-5, 15, 0).")
assert_false("between(12, 15, 6).")
assert_false("between(12, 15, 16).")
heaps = collect_all(Engine(), "between(1, 4, X).")
assert len(heaps) == 4
assert heaps[0]['X'].num == 1
assert heaps[-1]['X'].num == 4
def test_functional_test():
e = Engine(load_system=True)
env = assert_true("append([1, 2, 3, 4, 5], [2, 3, 4, 5, 6], X).", e)
res = env['X']
l = []
while res.name() == ".":
l.append(res.argument_at(0).num)
res = res.argument_at(1)
assert l == [1, 2, 3, 4, 5, 2, 3, 4, 5, 6]
def test_library_dir_single_query():
e = Engine()
tempdir = "__temp__"
create_dir(tempdir)
try:
assert_true("add_library_dir('%s')." % tempdir, e)
assert_true("library_directory('%s')." % tempdir, e)
finally:
delete_dir(tempdir)
def test_asserta_other_module():
e = Engine()
assert_true("asserta(m:f(a)).", e)
assert len(e.modulewrapper.modules) == 2
assert_true("m:f(a).", e)
prolog_raises("existence_error(_, _)", "f(a)", e)
assert_true("module(m).", e)
assert_true("f(a).", e)
assert_true("module(user).", e)
prolog_raises("existence_error(_, _)", "f(a)", e)
def test_importlist_with_not_existing_rule():
e = Engine()
m = "mod"
create_file(m, """
:- module('%s', [f/1]).
""" % m)
try:
prolog_raises("import_error(mod, 'f/1')", "use_module(%s)" % m, e)
assert e.modulewrapper.current_module.name == "user"
finally:
delete_file(m)
def test_load_broken_module_twice():
e = Engine()
m = "mod"
create_file(m, """
:- module(%s, [f/1]).
""" % m)
try:
prolog_raises("import_error(mod, 'f/1')", "use_module('%s')" % m, e)
assert_true("use_module('%s')." % m, e)
assert m in e.modulewrapper.modules
finally:
delete_file(m)
def test_unify_default_alias():
src = "__src__"
create_file(src, "")
try:
e = Engine()
assert_true("open('%s', read, S)." % src, e)
assert len(e.streamwrapper.aliases) == 3
for key in e.streamwrapper.aliases.keys():
if not key.endswith("_0") and not key.endswith("_1"):
alias = key
assert_true("S = '%s'." % alias, e)
finally:
delete_file(src)
def test_dont_clone_ground_arg():
m = Engine().modulewrapper
n = Number(1)
n.unify_and_standardize_apart = None
head = Callable.build("f", [n])
r = Rule(head, C(2), m.user_module)
assert r.groundargs == [True]
b = BindingVar()
callhead = Callable.build("f", [b])
h = Heap()
# should not fail, because ground args don't need cloning
r.clone_and_unify_head(h, callhead)
def test_list():
f = formatting.TermFormatter(Engine(), quoted=False, ignore_ops=False)
t = parse_query_term("[1, 2, 3, 4, 5 | X].")
assert f.format(t) == "[1, 2, 3, 4, 5|_G0]"
t = parse_query_term("[a, b, 'A$%%$$'|[]].")
assert f.format(t) == "[a, b, A$%%$$]"
t = parse_query_term("'.'(a, b, c).")
assert f.format(t) == ".(a, b, c)"
X = BindingVar()
a = Callable.build('a')
t = Callable.build(".", [a, X])
X.binding = Callable.build(".", [a, Callable.build("[]")])
assert f.format(t) == "[a, a]"
def entry_point(argv):
if len(argv) != 8:
print(
"Usage: spyrolog PROGRAM SIMILARITIES QUERY1|QUERY2|...|QUERYN MAX_DEPTH LAMBDA_CUT1|LAMBDA_CUT2|...|LAMBDA_CUTN E-TNORM|P-TNORM MIN_WIDTH"
)
return 1
program_fname = argv[1]
sim_fname = argv[2]
queries = argv[3]
max_depth = int(argv[4])
lambda_cuts = [float(i) for i in argv[5].split('|')]
entity_tnorm, predicate_tnorm = argv[6].split('|')
min_width = int(argv[7])
sim = get_similarity_from_file(sim_fname, 0, entity_tnorm, predicate_tnorm)
e = Engine(load_system=False, similarity=sim, max_depth=max_depth)
e.modulewrapper.current_module = e.modulewrapper.user_module
with open(program_fname) as f:
sim.parse_rulescores(f.read(), e)
query_idx = 0
for query in queries.split('|'):
cut = lambda_cuts[query_idx]
scores = []
depths = []
rules = []
unifications = []
sim.lambda_cut = cut
sim.reset_threshold()
sim.query_idx = query_idx
collector = GetAllScoresContinuation(e, scores, sim, depths, rules,
unifications, min_width)
e.max_depth = max_depth
goals, var_to_pos = e.parse(query)
goal = goals[0]
try:
e.run_query_in_current(goal, collector)
except UnificationFailed:
info = get_max_info(scores, depths, rules, unifications)
if info[0] > 0:
print(info[0], info[1], '|'.join(info[3]),
query + ''.join(info[2]))
else:
print(0.0, 0)
query_idx += 1
return 0
def test_engine_current_module_after_invalid_import():
m = "m.pl"
create_file(m, """
:- module(m, [f(a)]).
f(a).
""")
e = Engine()
try:
try: # XXX strange, prolog_raises does not catch the error
prolog_raises("type_error(_, _)", "use_module(m)", e)
except UncaughtError:
pass
assert e.modulewrapper.current_module.name == "user"
finally:
delete_file(m)
def test_module_assert_retract():
e = Engine()
assert_true("module(m).", e)
assert_true("assert(x).", e)
assert_true("asserta(y).", e)
assert_true("x, y.", e)
assert_true("module(user).", e)
assert_false("retract(x).", e)
assert_false("retract(y).", e)
assert_true("assert(x).", e)
assert_true("x.", e)
assert_true("module(m).", e)
assert_true("retract(x).", e)
prolog_raises("existence_error(X, Y)", "x", e)
assert_true("module(user).", e)
assert_true("x.", e)
def test_add_library_twice():
e = Engine()
lib1 = "__lib1__"
lib2 = "__lib2__"
create_dir(lib1)
create_dir(lib2)
try:
assert_true("add_library_dir('%s')." % lib1, e)
assert len(e.modulewrapper.libs) == 1
assert_true("add_library_dir('%s')." % lib1, e)
assert len(e.modulewrapper.libs) == 1
assert_true("add_library_dir('%s')." % lib2, e)
assert len(e.modulewrapper.libs) == 2
finally:
delete_dir(lib1)
delete_dir(lib2)
def test_seen():
src = "__src__"
create_file(src, "asdasd")
try:
e = Engine()
w = e.streamwrapper
assert_true("open('%s', read, S), set_input(S)." % src, e)
assert len(w.streams) == 3
assert len(w.aliases) == 3
assert w.current_instream.fd() not in [0, 1]
assert_true("seen.", e)
assert len(w.streams) == 2
assert len(w.aliases) == 2
assert w.current_instream.fd() == 0
finally:
delete_file(src)
def test_open():
src = "__src__"
create_file(src, "")
try:
e = Engine()
assert_true("open('%s', read, S)." % src, e)
assert len(e.streamwrapper.streams) == 3
prolog_raises("existence_error(X, Y)",
"open('does_not_exist', read, S)")
prolog_raises("type_error(X, Y)", "open('%s', read, a)" % src)
assert_true("open('%s', write, S)." % src)
assert_true("open('%s', append, S)." % src)
prolog_raises("domain_error(X, Y)", "open('%s', asdsadsad, X)")
finally:
delete_file(src)
def test_close_current_output():
src = "__src__"
create_file(src, "")
try:
e = Engine()
w = e.streamwrapper
assert w.current_outstream.alias == "$stream_1"
assert_true(
"""
open('%s', write, S),
set_output(S),
close(S).
""" % src, e)
assert w.current_outstream.alias == "$stream_1"
finally:
delete_file(src)
def entry_point(argv):
if len(argv) != 4:
print "Wrong number of arguments"
return 1
with open(argv[1]) as f:
program = f.read()
similarity = from_file(argv[2])
engine = Engine()
term.DEBUG = False
# results = collect_all(e, argv[3])
max_score = 0.0
# for result in results:
# max_score = max(max_score, result[1])
# print max_score
return 0
def test_prefix_module_in_other_directory():
d = "__dir__"
create_dir(d)
m = "mod"
create_file("%s/%s" % (d, m), """
:- module(%s, [f/1]).
f(a).
""" % m)
e = Engine()
try:
assert_true("use_module('%s/%s')." % (d, m), e)
assert_true("current_module(%s)." % m, e)
assert_true("%s:f(X), X == a." % m, e)
finally:
delete_dir(d)
def test_ground_args():
e = Engine()
m = e.modulewrapper
r = Rule(C(1), C(2), m.user_module)
assert r.groundargs is None
head = Callable.build("f", [Number(1)])
r = Rule(head, C(2), m.user_module)
assert r.groundargs == [True]
head = Callable.build("f", [
Callable.build("g", [Number(1)]),
BindingVar(),
Callable.build("h", [Number(2), BindingVar()])
])
r = Rule(head, C(2), m.user_module)
assert r.groundargs == [True, False, False]
def test_put_attrs():
e = Engine(load_system=True)
assert_false("put_attrs(X, []), attvar(X).", e)
prolog_raises("representation_error(A, B)", "put_attrs(a, [])", e)
prolog_raises("representation_error(A, B)", "put_attrs(a, att(m, 1, []))",
e)
assert_true("put_attrs(X, att(m, 1, [])), get_attr(X, m, 1).", e)
assert_true(
"put_attrs(X, att(m, 1, att(n, W, []))), get_attr(X, m, 1), get_attr(X, n, W).",
e)
assert_false("put_attrs(X, att(m, 1, [])), fail; attvar(X).", e)
assert_true(
"put_attr(X, m, 1), (put_attrs(X, att(m, 2, [])), fail; true), get_attr(X, m, 1).",
e)
assert_true(
"put_attr(X, m, 1), put_attrs(X, att(m, 2, [])), get_attr(X, m, 2).",
e)
def test_parser_access():
assert_true("current_op(200, xfx, **).")
f = collect_all(Engine(), "current_op(200, Form, X).")
assert len(f) == 2
e = get_engine("""
foo(a, b).
""")
assert_true("op(450, xfy, foo).", e)
assert_true("a foo b.", e)
assert_true("op(0, xfy, foo).", e)
# XXX really a ParseError
py.test.raises(Exception, assert_false, "a foo b.", e)
# change precedence of + for funny results :-)
assert_true("14 is 2 + 3 * 4.", e)
assert_true("op(350, xfy, +).", e)
assert_true("20 is 2 + 3 * 4.", e)
assert_true("op(500, xfy, +).", e)
def test_run():
e = Engine()
e.add_rule(Callable.build("f", [Callable.build("a"), Callable.build("b")]))
X = BindingVar()
Y = BindingVar()
c = Callable.build("f", [X, X])
e.add_rule(c)
c2 = Callable.build(
":-", [Callable.build("f", [X, Y]),
Callable.build("f", [Y, X])])
e.add_rule(c2)
hp = Heap()
X = hp.newvar()
c3 = Callable.build("f", [Callable.build("b"), X])
e.run_query_in_current(c3)
assert X.dereference(hp).name() == "b"
query = Callable.build("f", [Callable.build("b"), Callable.build("a")])
e.run_query_in_current(query)
def test_set_output():
src = "__src__"
create_file(src, "")
try:
e = Engine()
assert_true(
"""
open('%s', write, S),
set_output(S),
current_output(S).
""" % src, e)
assert len(e.streamwrapper.streams) == 3
for key in e.streamwrapper.streams.keys():
if key not in [0, 1]:
fd = key
break
assert e.streamwrapper.current_outstream.fd() == fd
finally:
delete_file(src)