def test_unify_nullary(self):
raws = [
Function("afact",[Number(1),String("test")]),
Function("nullary1",[]),
Function("nullary2",[]),
Function("afact",[Number(2),String("test")]),
]
class Afact(Predicate):
anum=IntegerField()
astr=StringField()
class Meta: name = "afact"
class Nullary1(Predicate):
class Meta: name = "nullary1"
class Nullary2(Predicate):
class Meta: name = "nullary2"
af_1=Afact(anum=1,astr="test")
af_2=Afact(anum=2,astr="test")
u_1=Nullary1()
u_2=Nullary2()
self.assertEqual(list(unify([Nullary1],raws)),[u_1])
self.assertEqual(list(unify([Nullary2],raws)),[u_2])
self.assertEqual(set(unify([Afact,Nullary1,Nullary2],raws)),
set([af_1,af_2,u_1,u_2]))
def test_unify_same_sig(self):
class ATuple(ComplexTerm):
aconst=ConstantField()
bint = IntegerField()
class Meta: is_tuple = True
class Fact1(Predicate):
aint = IntegerField()
aconst = ConstantField()
class Meta: name = "fact"
class Fact2(Predicate):
aint = IntegerField()
atuple = ATuple.Field()
class Meta: name = "fact"
r1 = Function("fact",[Number(1), Function("bob",[])])
r2 = Function("fact",[Number(1), Function("", [Function("bob",[]),Number(1)])])
# r1 only unifies with Fact1 and r2 only unifies with Fact2
f1 = Fact1(raw=r1)
self.assertEqual(f1.raw, r1)
with self.assertRaises(ValueError) as ctx:
f2 = Fact1(raw=r2)
f2 = Fact2(raw=r2)
self.assertEqual(f2.raw, r2)
with self.assertRaises(ValueError) as ctx:
f1 = Fact2(raw=r1)
# The unify() function should correctly unify both facts
res = unify([Fact1,Fact2],[r1,r2])
self.assertEqual(len(res), 2)
def test_unify_catch_exceptions(self):
# Define a class that converts strings but makes bad exceptions for any
# other input
class TmpField(BaseField):
def cltopy(raw):
if raw.type == SymbolType.String:
return raw.string
return blah.blah.error1(raw)
def pytocl(v):
if isinstance(v,str): return String(v)
import blah
return blah.error2(v)
# This is good
self.assertEqual(TmpField.cltopy(String("blah")), "blah")
self.assertEqual(TmpField.pytocl("blah"), String("blah"))
# Some things that should throw an exception
with self.assertRaises(AttributeError) as ctx:
r=TmpField.cltopy(1)
check_errmsg("'int' object has no attribute 'type'",ctx)
with self.assertRaises(NameError) as ctx:
r=TmpField.cltopy(Number(1))
check_errmsg("name 'blah' is not defined",ctx)
with self.assertRaises(ModuleNotFoundError) as ctx:
r=TmpField.pytocl(1)
check_errmsg("No module named 'blah'",ctx)
class F(Predicate):
v=TmpField
# Ok
raw=Function("f",[String("astring")])
unify([F],[raw])
# Bad
with self.assertRaises(NameError) as ctx:
raw=Function("f",[Number(1)])
unify([F],[raw])
check_errmsg("name 'blah' is not defined",ctx)
def test_unify_signed_literals(self):
class F1(Predicate):
a = IntegerField
class Meta:
name = "f"
sign = True
class F2(Predicate):
a = IntegerField
class Meta:
name = "f"
sign = False
pos_raw1 = Function("f",[Number(1)])
pos_raw2 = Function("f",[Number(2)])
neg_raw1 = Function("f",[Number(1)],False)
neg_raw2 = Function("f",[Number(2)],False)
pos1 = F1(a=1)
pos2 = F1(a=2)
neg1 = F2(a=1,sign=False)
neg2 = F2(a=2,sign=False)
# unify with all raw
fb = unify([F1,F2], [ pos_raw1, pos_raw2, neg_raw1, neg_raw2])
self.assertEqual(len(fb), 4)
self.assertEqual(set(fb.query(F1).all()), set([pos1,pos2]))
self.assertEqual(set(fb.query(F2).all()), set([neg1,neg2]))
fb = unify([F1], [ pos_raw1, pos_raw2, neg_raw1, neg_raw2])
self.assertEqual(len(fb), 2)
self.assertEqual(fb.query(F1).count(), 2)
fb = unify([F2], [ pos_raw1, pos_raw2, neg_raw1, neg_raw2])
self.assertEqual(len(fb), 2)
self.assertEqual(fb.query(F2).count(), 2)
with self.assertRaises(ValueError) as ctx:
bad1 = F1(a=1,sign=False)
def test_unify_same_sig2(self):
class Fact1(Predicate):
aint = IntegerField()
aconst = ConstantField()
class Meta: name = "fact"
class Fact2(Predicate):
aint = IntegerField()
araw = RawField()
class Meta: name = "fact"
r1 = Function("fact",[Number(1), Function("bob",[])])
r2 = Function("fact",[Number(1), Function("", [Function("bob",[]),Number(1)])])
# r1 only unifies with Fact1 but both r1 and r2 unify with Fact2
f1 = Fact1(raw=r1)
self.assertEqual(f1.raw, r1)
with self.assertRaises(ValueError) as ctx:
f2 = Fact1(raw=r2)
f1_alt = Fact2(raw=r1)
self.assertEqual(f1_alt.raw, r1)
f2 = Fact2(raw=r2)
self.assertEqual(f2.raw, r2)
# unify() unifies r1 with Fact1 (f1) and r2 with Fact2 (f2)
res = unify([Fact1,Fact2],[r1,r2])
self.assertEqual(len(res), 2)
self.assertTrue(f1 in res)
self.assertTrue(f2 in res)
# unify() unifies r1 and r2 with Fact2 (f1_alt and f2)
res = unify([Fact2,Fact1],[r1,r2])
self.assertEqual(len(res), 2)
self.assertTrue(f1_alt in res)
self.assertTrue(f2 in res)
def test_unify(self):
raws = [
Function("afact",[Number(1),String("test")]),
Function("afact",[Number(2),Number(3),String("test")]),
Function("afact",[Number(1),Function("fun",[Number(1)])]),
Function("bfact",[Number(3),String("test")])
]
class Afact1(Predicate):
anum=IntegerField()
astr=StringField()
class Meta: name = "afact"
class Afact2(Predicate):
anum1=IntegerField()
anum2=IntegerField()
astr=StringField()
class Meta: name = "afact"
class Afact3(Predicate):
class Fun(ComplexTerm):
fnum=IntegerField()
anum=IntegerField()
afun=Fun.Field()
# afun=ComplexField(Fun)
class Meta: name = "afact"
class Bfact(Predicate):
anum=IntegerField()
astr=StringField()
af1_1=Afact1(anum=1,astr="test")
af2_1=Afact2(anum1=2,anum2=3,astr="test")
af3_1=Afact3(anum=1,afun=Afact3.Fun(fnum=1))
bf_1=Bfact(anum=3,astr="test")
g1=list(unify([Afact1],raws))
g2=list(unify([Afact2],raws))
g3=list(unify([Afact3],raws))
g4=list(unify([Bfact],raws))
g5=list(unify([Afact1,Bfact],raws))
self.assertEqual([af1_1], g1)
self.assertEqual([af2_1], g2)
self.assertEqual([af3_1], g3)
self.assertEqual([bf_1], g4)
self.assertEqual([af1_1,bf_1], g5)
# Test the ordered option that returns a list of facts that preserves
# the order of the original symbols.
g1=unify([Afact1,Afact2,Bfact], raws, ordered=True)
self.assertEqual(g1, [af1_1,af2_1,bf_1])
def test_predicate_instance_raw_term(self):
raw1 = Function("func",[Number(1)])
raw2 = Function("bob",[String("no")])
rf1 = RawField()
rt1 = Function("tmp", [Number(1), raw1])
rt2 = Function("tmp", [Number(1), raw2])
self.assertTrue(rf1.unifies(raw1))
class Tmp(Predicate):
n1 = IntegerField()
r1 = RawField()
self.assertTrue(Tmp._unify(rt1) is not None)
self.assertTrue(Tmp._unify(rt2) is not None)
t1 = Tmp(1,Raw(raw1))
t2 = Tmp(1,Raw(raw2))
self.assertEqual(set([f for f in unify([Tmp], [rt1,rt2])]),set([t1,t2]))
self.assertEqual(t1.r1.symbol, raw1)
self.assertEqual(t2.r1.symbol, raw2)