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 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 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 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 answer(self):
start_time = time.time()
answer_ids = []
answers = []
new_answers = [
Response(self.language, self.tree, self.measures, self.trace)
]
for i in range(0, self.config.nb_passes):
# Perform the pass
requests = list(map(self.request_from_answer, new_answers))
new_answers = []
for request in requests:
new_answers.extend(self.one_pass(request))
# Remove duplicates, and update the answer list
new_answers = list(remove_duplicates(answer_ids, new_answers))
answers.extend(new_answers)
# TODO: should sort according to accuracy too
answers = sorted(
answers,
key=lambda x: x.measures.get('relevance', DEFAULT_RELEVANCE),
reverse=True)
# Log answers in an other thread, so it does not add a delay.
end_time = time.time()
threading.Thread(target=verbose_log.log_answers,
args=(self.config, answers, start_time,
end_time)).start()
return answers
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 testEquality(self):
self.assertEqual(Response('en', Resource(value='foo'), {}, []),
Response('en', Resource(value='foo'), {}, []))
self.assertNotEqual(Response('en', Resource(value='foo'), {}, []),
Response('en', Resource(value='bar'), {}, []))
self.assertNotEqual(
Response('en', Resource(value='foo'), {'accuracy': 0.5}, []),
Response('en', Resource(value='foo'), {'accuracy': 0.6}, []))
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 answer(self):
return [Response('en', self.request.tree, {}, [])]
def build_answer(request, tree, measures, module_name):
trace = request.trace + [TraceItem(module_name, tree, measures, {})]
return Response(request.language, tree, measures, trace)