def testFromDict(self):
d = {
'tree': {
'type': 'missing'
},
'module': 'foo',
'measures': {},
'times': {}
}
self.assertEqual(TraceItem.from_dict(d),
TraceItem('foo', Missing(), {}, {}))
def answer(self):
if not isinstance(self.tree, Sentence):
return []
mathNotation = isMath(self.tree.value)
if mathNotation == 0 or traceContainsSpellChecker(self.trace):
return []
try:
outputString, outputLatex = process(evaluate,
self.tree.value,
timeout=Config().timeout,
heap_size=Config().max_heap)
except (ValueError, SyntaxError):
return []
if not isInteresting(str(self.tree.value),
outputString) and mathNotation == 1:
return []
outputTree = MathLatexResource(outputString, latex=outputLatex)
measures = {
'accuracy': 1, # Indeed we hope maths are consistent
'relevance': relevance(self.tree.value, outputString)
}
trace = self.trace + [TraceItem('CAS', outputTree, measures)]
response = Response(self.language, outputTree, measures, trace)
return [response]
def my_module2_mock(url, request):
body = Request.from_json(request.body)
m = {'relevance': 0.3, 'accuracy': 1}
response = Response('en', body.tree, m,
[TraceItem('module2', body.tree, m)])
return {'status_code': 200,
'content': '[%s]' % response.as_json()}
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 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 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 testWorking(self):
t = T(M(), M(), M())
q = {
'id': '1',
'language': 'en',
'tree': t.as_dict(),
'measures': {},
'trace': []
}
self.assertResponse(
q,
[Response('en', R('bar'), {}, [TraceItem('test', R('bar'), {})])])
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 answer(self):
if not isinstance(self.request.tree, Sentence) or \
self.request.language != 'en':
return []
sentence = self.request.tree.value
try:
tree = parse(sentence)
except QuotationError: # no logging, the error is between the chair and the keyboard
return []
except KeyboardInterrupt:
raise
except Exception as e:
logging.warning(e)
return []
if isinstance(tree, (Resource, List)):
return []
meas = {'accuracy': 0.5, 'relevance': 0.5}
trace = self.request.trace + [
TraceItem('QuestionParsing-Grammatical', tree, meas)
]
response = Response('en', tree, meas, trace)
return [response]
def testFromDict(self):
d = {'tree': {'type': 'missing'}, 'module': 'foo', 'measures': {}, 'times': {}}
self.assertEqual(TraceItem.from_dict(d),
TraceItem('foo', Missing(), {}, {}))
def testLegacyTraceItem(self):
self.assertEqual(TraceItem('foo', Resource(value='bar'), {}),
TraceItem('foo', Resource(value='bar'), {}, {}))
def build_answer(request, tree, measures, module_name):
trace = request.trace + [TraceItem(module_name, tree, measures, {})]
return Response(request.language, tree, measures, trace)