def infer(self, document_response, tagger_model_path):
tagger = LDATagger(tagger_model_path,
num_topics=config("app.max_topics"))
topics = tagger.topics_for_document(document_response.tokens())
topics_tokens_map = tagger.topics_to_tokens()
tags = TagGenerator(topics_tokens_map).generate_tags(
topics=topics, tokens=document_response.tokens())
try:
self.content_store_service.post_document_logical_topics_association(
document_response.document_id(), topics, topics_tokens_map)
except Exception as e:
document_topic_error_msg = "Error updating content store for document with logical topics"
logger.error(e)
return self.error_response(document_topic_error_msg)
try:
self.content_store_service.post_document_tags_association(
document_response.document_id(), tags)
except Exception as e:
doc_tags_error_msg = "Error updating content store with Document Tags"
logger.error(e)
return self.error_response(doc_tags_error_msg)
return Response(status="success", message="Process Complete")
def process(self, docs_tokens_map, tagger_model_path):
tagger = LDATagger(tagger_model_path,
num_topics=config("app.max_topics"))
tagger.build_or_update_model(docs_tokens_map.values())
docs_topics_map = tagger.topics_for_documents(docs_tokens_map)
topics_tokens_map = tagger.topics_to_tokens()
docs_tags_map = TagGenerator(
topics_tokens_map).generate_documents_tag_map(
documents_tokens_map=docs_tokens_map,
documents_topics_map=docs_topics_map)
try:
self.content_store_service.post_documents_logical_topics_associations(
docs_topics_map, topics_tokens_map)
except Exception as e:
document_topic_error_msg = "Error updating content store for documents with logical topics"
logger.error(e)
return self.error_response(document_topic_error_msg)
try:
self.content_store_service.post_documents_tags_associations(
docs_tags_map)
except Exception as e:
docs_tags_error_msg = "Error updating content store with Documents' Tags"
logger.error(e)
return self.error_response(docs_tags_error_msg)
return Response(status="success", message="Process Complete")
def wrapper(*args, **kwargs):
handler = args[0]
self.executor.submit(partial(f, *args, **kwargs))
self.logger.debug("Writing Async Response for %s" %
handler.__class__)
handler.write(
Response(message="Successfully received request for %s" %
handler.__class__).to_json())
handler.set_header("Content-Type", "application/json")
handler.finish()
def post(self):
"""
Accepts a request with json as below:
{
"resources" : [resource1,resource2..]
"callback_url": "callback url"
}
resource = {
"id": sha123,
"field1" : {
"value": bla,
"weight" : optional
},
"field2" : {
"value": bla bla,
"weight" : 2
}
}
"""
logger.info(
"Request Received to calculate similarity between resources")
parameters = json.loads(self.request.body)
HEADERS = {'Content-Type': 'application/json'}
callback_url = parameters["callback_url"]
try:
logger.info("Sample resource in request [%s]" %
(parameters["resources"][0]))
similarity_map = all_resources_similarity(
parameters["resources"], self.similarity_threshold)
except Exception as e:
logger.exception("Error while computing similarity!")
requests.post(callback_url,
data=Response(status="failure",
message=e.message).to_json(),
headers=HEADERS)
else:
logger.info(
"Similarity Calculation complete for resources, posting to [%s] with [%s]"
% (callback_url, json.dumps(similarity_map)))
requests.post(callback_url,
data=(json.dumps(similarity_map)),
headers=HEADERS)
def post(self):
logger.info("Request Received to calculate similarity between posts")
parameters = json.loads(self.request.body)
HEADERS = {'Content-Type': 'application/json'}
try:
similarity_map = self.similarity_service.find_similarity_across(
parameters["documents"])
except Exception as e:
logger.exception("Error while computing similarity!")
requests.post(parameters["callback_url"],
data=Response(status="failure",
message=e.message).to_json(),
headers=HEADERS)
else:
requests.post(parameters["callback_url"],
data=(json.dumps(similarity_map)),
headers=HEADERS)
def error_response(self, error_msg):
self.set_status(httplib.INTERNAL_SERVER_ERROR)
error_response = Response(status="failure", message=error_msg)
self.write(error_response.to_json())
self.set_header("Content-Type", "application/json")
def error_response(self, error_message):
logger.error(error_message)
return Response(status="failure", message=error_message)