def add_override(event, context):
try:
override_request = json.loads(event['body'])
keyword = override_request['keyword']
override_request['keyword'] = keyword
manual_override = override_request[
ResolutionAlgo.MANUAL_OVERRIDE.value]
manual_override['update_timestamp'] = get_timestamp()
manual_override['keyword'] = keyword
log.info(
f'Received manual override request for keyword {keyword}, and payload {override_request}'
)
if override_request is not None:
dynamo_result = dynamo_lookup_entity(keyword)
if not dynamo_result:
dynamo_save_override_entity(override_request)
else:
dynamo_result[
ResolutionAlgo.MANUAL_OVERRIDE.value] = manual_override
dynamo_save_override_entity(dynamo_result)
return construct_response(
requests.codes.ok,
f'Successfully added manual override for {keyword}')
except:
message = 'MANUAL-OVERRIDE: Error while processing a manual override request, ' \
'dropping into SNS for some hand holding'
return error_response(event, message, log)
def persist_unresolved_entity(keyword, state=UnresolvedEntityState.NEW.value):
item = {
'keyword': keyword,
'state': str(state),
'timestamp': get_timestamp()
}
__dynamo_save_item(item, get_unresolved_entities_table_name())
def __force_resolve_entity(response, table):
global inspected_count, CORRECTED_COUNT
for item in response['Items']:
inspected_count = inspected_count + 1
keyword_arg = item['keyword']
# Force Resolve
keyword = urllib.parse.quote(keyword_arg, safe='')
result = requests.post(url=f'{ers_url}/{keyword}')
if result.status_code is requests.codes.ok:
CORRECTED_COUNT = CORRECTED_COUNT + 1
__delete_item(keyword_arg, table)
print(
f'{CORRECTED_COUNT}/{inspected_count}: Fetched entity for [{keyword_arg}]'
)
print(f'FORCE-RESOLVE: {result.status_code}\n')
else:
if (result.status_code -
requests.codes.internal_server_error) >= 0:
state = str(UnresolvedEntityState.FAILED.value)
else:
state = str(UnresolvedEntityState.RESOLUTION_FAILED.value)
item = {
'keyword': keyword_arg,
'state': state,
'timestamp': get_timestamp()
}
table.put_item(Item=item)
def __init__(self,
keyword,
entity_match,
open_calais,
manual_override=None):
self.keyword = keyword
self.entity_match = entity_match
self.open_calais = open_calais
self.manual_override = manual_override
self.update_timestamp = get_timestamp()
def __add_resolution(table, orig_keyword, entity, algo):
response = table.query(
KeyConditionExpression=Key('keyword').eq(orig_keyword))
global NEW_COUNT
if len(response['Items']) > 0:
for item in response['Items']:
item[algo] = entity
item['update_timestamp'] = get_timestamp()
__put_item(item, table)
else:
item = {
'keyword': orig_keyword,
algo: entity,
'update_timestamp': get_timestamp()
}
print(f'Item {orig_keyword} not found, should add new entry')
NEW_COUNT = NEW_COUNT + 1
__put_item(item, table)
def __re_resolve(result, table):
global CORRECTED_COUNT, RESOLVED_COUNT, DEFAULTED_COUNT, NEW_COUNT
orig_keyword = result['input']
entity = default_not_found_result(
resolution_algorithm=ResolutionAlgo.OPEN_CALAIS, keyword=orig_keyword)
try:
if result['matching'] is not None and result['matching'] is not '':
entity = _get_entity(orig_keyword, result)
RESOLVED_COUNT = RESOLVED_COUNT + 1
except KeyError:
DEFAULTED_COUNT = DEFAULTED_COUNT + 1
if entity is not None:
response = table.query(
KeyConditionExpression=Key('keyword').eq(orig_keyword))
if len(response['Items']) > 0:
for item in response['Items']:
item[ResolutionAlgo.OPEN_CALAIS.value] = entity
item['update_timestamp'] = get_timestamp()
__put_item(item, table)
else:
item = {
'keyword': orig_keyword,
ResolutionAlgo.OPEN_CALAIS.value: entity,
'update_timestamp': get_timestamp()
}
print(f'Item {orig_keyword} not found, should add new entry')
NEW_COUNT = NEW_COUNT + 1
__put_item(item, table)
CORRECTED_COUNT = CORRECTED_COUNT + 1
print(
f'{CORRECTED_COUNT}/{RESOLVED_COUNT}/{DEFAULTED_COUNT}/{NEW_COUNT}:- {entity} \n'
)
def __re_resolve(orig_keyword, result, table):
global CORRECTED_COUNT, NEW_COUNT
if result is not None and result is not '':
response = table.query(
KeyConditionExpression=Key('keyword').eq(orig_keyword))
if len(response['Items']) > 0:
for item in response['Items']:
item[ResolutionAlgo.ENTITY_MATCH.value] = result
item['update_timestamp'] = get_timestamp()
__put_item(item, table)
else:
item = {
'keyword': orig_keyword,
ResolutionAlgo.ENTITY_MATCH.value: result,
'update_timestamp': get_timestamp()
}
print(f'Item {orig_keyword} not found, should add new entry')
NEW_COUNT = NEW_COUNT + 1
__put_item(item, table)
CORRECTED_COUNT = CORRECTED_COUNT + 1
print(f'{CORRECTED_COUNT}/{NEW_COUNT}:- {result} \n')