def testTraverse(self):
def pred(tree):
if isinstance(tree, Resource):
return Resource('foo')
elif isinstance(tree, Triple):
return Triple(tree.subject, Resource('bar'), tree.object)
elif isinstance(tree, Missing):
return Resource('m')
else:
return tree
f = Resource('foo')
b = Resource('bar')
m = Resource('m')
self.assertEqual(Resource('baz').traverse(pred), f)
tree = Triple(Resource('1'), Resource('2'), Missing())
self.assertEqual(tree.traverse(pred), Triple(f, b, m))
tree = List([Resource('4'), Resource('5')])
self.assertEqual(tree.traverse(pred), List([f, f]))
tree = Triple(Triple(Resource('1'), Resource('2'), Missing()),
Resource('3'), List([Resource('4'),
Resource('5')]))
self.assertEqual(tree.traverse(pred),
Triple(Triple(f, b, m), b, List([
f,
f,
])))
tree = Union([List([Resource('1')]), List([Resource('2')])])
self.assertEqual(tree.traverse(pred), Union([List([f]), List([f])]))
tree = Intersection([List([Resource('1')]), List([Resource('2')])])
self.assertEqual(tree.traverse(pred),
Intersection([List([f]), List([f])]))
def testQueriesMultipleModuleWithFail(self):
self.config_file.write(one_valid_module_config)
self.config_file.seek(0)
q = Request('1', 'en', Missing(), {}, [])
m = {'relevance': 0.5, 'accuracy': 0.5}
with HTTMock(my_module_mock, my_module4_mock):
self.assertResponse(q, [
Response('en', Missing(), m,
[TraceItem('module1', Missing(), m)])])
def pred(node):
if isinstance(node, Exists):
return Resource('qux')
elif isinstance(node, List):
return Triple(Resource('baz'), Missing(), Missing())
elif isinstance(node, Resource):
return Resource('bar')
else:
assert False, node
def testInclusionTriple(self):
tree1 = Triple(Resource('foo'), List([Resource('a'),
Resource('b')]), Missing())
tree2 = Triple(List([Resource('bar'), Resource('foo')]),
List([Resource('a'),
Resource('d'),
Resource('b')]), Missing())
self.assertIncluded(tree1, tree2)
with self.assertRaises(AssertionError):
self.assertIncluded(tree2, tree1)
def testQueriesModule(self):
self.config_file.write(one_module_config)
self.config_file.seek(0)
q = {'id': '1', 'language': 'en', 'tree': {'type': 'triple',
'subject': {'type': 'resource', 'value': 'foo'},
'predicate': {'type': 'resource', 'value': 'bar'},
'object': {'type': 'resource', 'value': 'baz'}},
'measures': {}, 'trace': []}
m = {'relevance': 0.5, 'accuracy': 0.5}
with HTTMock(my_module_mock):
self.assertResponse(q, [
Response('en', Missing(), m,
[TraceItem('module1', Missing(), m)])])
def testFromJson(self):
r = {
'language':
'en',
'measures': {},
'trace': [{
'module': 'foo',
'tree': {
'type': 'missing'
},
'measures': {},
'times': {}
}],
'tree': {
'type': 'resource',
'value': 'foo'
}
}
t = [TraceItem('foo', Missing(), {}, {})]
self.assertEqual(Response('en', Resource(value='foo'), {}, t),
Response.from_json(json.dumps(r)))
self.assertEqual(Response('en', Resource(value='foo'), {}, t),
Response.from_dict(r))
self.assertEqual(Response('en', Resource(value='foo'), {}, t),
Response.from_json(json.dumps(r)))
self.assertEqual(json.loads(Response.from_dict(r).as_json()), r)
def testNoDuplicate(self):
q = Request('1', 'en', Missing(), {}, [])
with HTTMock(my_module3_mock, my_module3b_mock):
answers = self.request(q)
self.assertNotEqual(len(answers), 20, answers)
self.assertNotEqual(len(answers), 10, answers)
self.assertNotEqual(len(answers), 2, answers)
self.assertEqual(len(answers), 1, answers)
def testMultiplePredicates(self):
q = Request(
'1', 'en',
Triple(Resource('1 2 4 8'),
List([Resource('definition'),
Resource('foo')]), Missing()), {}, [])
r = self.request(q)
self.assertGreater(len(r), 1, r)
def testToJsonNone(self):
n = Triple(subject=R('s'), predicate=R('p'), object=Missing())
self.assertEqual(
json.loads(n.as_json()), {
'type': 'triple',
'subject': r('s'),
'predicate': r('p'),
'object': m()
})
def testBlacklist(self):
with HTTMock(my_module1_mock, my_module2_mock):
q = Request('1', 'en', Sentence('foo'), {}, [])
answers = self.request(q)
self.assertEqual(len(answers), 2, answers)
q = Request('1', 'en', Missing(), {}, [])
answers = self.request(q)
self.assertEqual(len(answers), 1, answers)
self.assertEqual(answers[0].tree.value, 'one')
def testInclusionIntersectionUnionAndOr(self):
tree1 = Triple(Resource('foo'), List([Resource('a'),
Resource('b')]), Missing())
tree2 = Triple(List([Resource('bar'), Resource('foo')]),
List([Resource('a'),
Resource('d'),
Resource('b')]), Missing())
tree3 = Missing()
for op in [Intersection, Union, And, Or]:
self.assertIncluded(op([tree1]), op([tree2]))
with self.assertRaises(AssertionError):
self.assertIncluded(op([tree2]), op([tree1]))
self.assertIncluded(op([tree1, tree3]), op([tree1, tree3]))
self.assertIncluded(op([tree1, tree3]), op([tree3, tree1]))
with self.assertRaises(AssertionError):
self.assertIncluded(op([tree1, tree3]), op([tree1]))
with self.assertRaises(AssertionError):
self.assertIncluded(op([tree1]), op([tree3]))
def testInclusionFirstLastSort(self):
tree1 = Triple(Resource('foo'), List([Resource('a'),
Resource('b')]), Missing())
tree2 = Triple(List([Resource('bar'), Resource('foo')]),
List([Resource('a'),
Resource('d'),
Resource('b')]), Missing())
for op in (last, first):
self.assertIncluded(op(tree1), op(tree2))
with self.assertRaises(AssertionError):
self.assertIncluded(op(tree2), op(tree1))
self.assertIncluded(Sort(tree1, Resource('pred')),
Sort(tree2, Resource('pred')))
with self.assertRaises(AssertionError):
self.assertIncluded(Sort(tree2, Resource('pred')),
Sort(tree1, Resource('pred')))
with self.assertRaises(AssertionError):
self.assertIncluded(Sort(tree1, Resource('pred')),
Sort(tree2, Resource('derp')))
def testInclusionDifferentType(self):
l = [Resource('foo'), Missing(), Triple(Resource('foo'),
Resource('foo'), Resource('foo')),\
Intersection([Resource('foo')]), Union([Resource('foo')]),\
And([Resource('foo')]), Or([Resource('foo')]),
Exists(Resource('foo')), first(Resource('foo')),
last(Resource('foo')), Sort(Resource('foo'), Resource('pred'))]
for (t1, t2) in itertools.permutations(l, 2):
with self.assertRaises(AssertionError):
self.assertFalse(self.assertIncluded(t1, t2))
def testBasics(self):
q = Request(
'1', 'en',
Triple(Resource('1 2 4 8'), Resource('definition'), Missing()), {},
[])
r = self.request(q)
self.assertGreater(len(r), 1, r)
self.assertEqual(r[0].tree.value, 'Powers of 2: a(n) = 2^n.')
self.assertEqual(r[0].tree.graph['name'], 'Powers of 2: a(n) = 2^n.')
self.assertEqual(r[0].tree.graph['@id'], 'http://oeis.org/A000079')
def testFromDict(self):
d = {
'tree': {
'type': 'missing'
},
'module': 'foo',
'measures': {},
'times': {}
}
self.assertEqual(TraceItem.from_dict(d),
TraceItem('foo', Missing(), {}, {}))
def testInclusionBasic(self):
self.assertIncluded(Missing(), Missing())
self.assertIncluded(Resource('foo'), Resource('foo'))
with self.assertRaises(AssertionError):
self.assertIncluded(Resource('foo'), Resource('bar'))
self.assertIncluded(List([Resource('foo')]), Resource('foo'))
with self.assertRaises(AssertionError):
self.assertIncluded(List([Resource('foo')]), Resource('bar'))
self.assertIncluded(Resource('foo'), List([Resource('foo')]))
with self.assertRaises(AssertionError):
self.assertIncluded(Resource('foo'), List([Resource('bar')]))
self.assertIncluded(List([Resource('foo')]), List([Resource('foo')]))
with self.assertRaises(AssertionError):
self.assertIncluded(List([Resource('foo')]),
List([Resource('bar')]))
self.assertIncluded(List([Resource('foo')]),
List([Resource('foo'),
Resource('bar')]))
with self.assertRaises(AssertionError):
self.assertIncluded(List([Resource('foo'),
Resource('bar')]),
List([Resource('foo')]))
def normalize(tree):
"""
Map the tree to a normal form
"""
if tree.child == []: # leaf
return buildValue(tree)
if tree.child[0].dependency == 'Rexist':
return Exists(normalize(tree.child[0]))
if tree.child[0].dependency == 'Rspl':
return normalizeSuperlative(tree)
if tree.child[0].dependency.startswith('Rconj'):
return normalizeConjunction(tree)
result = []
for t in tree.child:
if t.dependency == 'R0':
result.append(normalize(t))
if t.dependency == 'R1':
result.append(buildValue(t))
if t.dependency == 'R2':
pred = buildPredicate(tree)
if pred[1]:
result.append(Triple(normalize(t), pred[0], Missing(),
pred[1]))
else:
result.append(Triple(normalize(t), pred[0], Missing()))
if t.dependency == 'R3':
pred = buildPredicate(tree)
if pred[1]:
result.append(Triple(Missing(), pred[0], normalize(t),
pred[1]))
else:
result.append(Triple(Missing(), pred[0], normalize(t)))
if t.dependency == 'RinstOf':
result.append(
Triple(Missing(), Resource('instance of'), normalize(t)))
if len(result) == 1:
return result[0]
else:
return Intersection(result)
def testEq(self):
self.assertEqual(Missing(), Missing())
self.assertEqual(Resource('foo'), Resource('foo'))
self.assertNotEqual(Missing(), Resource('foo'))
self.assertEqual(Missing(), {'type': 'missing'})
self.assertNotEqual(Missing(), {'type': 'missing', 'f': 'b'})
self.assertEqual(Resource('foo'), {'type': 'resource', 'value': 'foo'})
self.assertNotEqual(Missing(), '')
def testBasics(self):
q = Request(
'1', 'en',
Triple(Resource('1 2 4 8'), Resource('following'), Missing()), {},
[])
r = self.request(q)
self.assertGreater(len(r), 1, r)
self.assertTrue(r[0].tree.value.startswith('16, 32, 64'), r[0])
self.assertEqual(r[0].tree.graph['name'], 'Powers of 2: a(n) = 2^n.')
self.assertEqual(r[0].tree.graph['@id'], 'http://oeis.org/A000079')
self.assertEqual(r[0].tree.graph['description'][0], {
'@value': '2^0 = 1 is the only odd power of 2.',
'@language': 'en'
})
def testQueriesMultipleModule(self):
self.config_file.write(three_modules_config)
self.config_file.seek(0)
q = Request('1', 'en', Missing(), {}, [])
m1 = {'relevance': 0.5, 'accuracy': 0.5}
m2 = {'relevance': 0.3, 'accuracy': 1}
m3 = {'relevance': 0.55, 'accuracy': 0.5}
with HTTMock(my_module_mock, my_module2_mock, my_module3_mock):
self.assertResponse(q, [
Response('en', Missing(), m3,
[TraceItem('module3', Missing(), m3)]),
Response('en', Missing(), m1,
[TraceItem('module1', Missing(), m1)]),
Response('en', Missing(), m2,
[TraceItem('module2', Missing(), m2)]),
])
def testTripleIntersection(self):
t = Intersection([
Triple(Resource('a'), Resource('b'), Missing()),
Triple(Resource('c'), Resource('d'), Missing())
])
AbstractNode.from_dict(t.as_dict())
def testNoAnswer(self):
q = Request('1', 'en',
Triple(Resource('1 2'), Resource('definition'), Missing()),
{}, [])
r = self.request(q)
self.assertEqual(r, [])
