def lgr_set_annotate_task(lgr_json, script_lgr_json, labels_json, email_address, storage_path):
"""
Compute dispositions of labels in a LGR.
:param lgr_json: The LGRInfo as a JSON object.
:param script_lgr_json: The LGRinfo for the script used to check label validity as a JSON object.
:param labels_json: The LabelInfo as a JSON object.
:param email_address: The e-mail address where the results will be sent
:param storage_path: The place where results will be stored
"""
lgr_info = LGRInfo.from_dict(lgr_json)
script_lgr = LGRInfo.from_dict(script_lgr_json).lgr
labels_info = LabelInfo.from_dict(labels_json)
set_labels_info = lgr_info.set_labels_info
if set_labels_info is None:
set_labels_info = LabelInfo(name='None', labels=[])
logger.info("Starting task 'annotate' for LGR set %s, with set labels %s, for file %s",
lgr_info.name, set_labels_info.name, labels_info.name)
body = "Hi,\nThe processing of annotation from labels provided in the " \
"file '{f}' in LGR set '{lgr}' with script '{script}' has".format(f=labels_info.name,
lgr=lgr_info.lgr.name,
script=script_lgr.name)
_lgr_tool_task(storage_path,
base_filename='annotation_{0}'.format(lgr_info.lgr.name),
email_subject='LGR Toolset annotation result',
email_body=body,
email_address=email_address,
cb=lgr_set_annotate_labels,
lgr=lgr_info.lgr,
script_lgr=script_lgr,
set_labels=set_labels_info.labels,
labels_file=labels_info.labels)
def lgr_annotate(request, lgr_id):
lgr_info = None
if lgr_id is not None:
lgr_info = session_select_lgr(request, lgr_id)
form = _create_set_compatible_form_instance(LGRAnnotateSelector,
request, lgr_id)
if form.is_valid():
ctx = {}
lgr_id = form.cleaned_data['lgr']
labels_file = form.cleaned_data['labels']
email_address = form.cleaned_data['email']
lgr_info = session_select_lgr(request, lgr_id)
storage_path = session_get_storage(request)
# need to transmit json serializable data
labels_json = LabelInfo.from_form(labels_file.name,
labels_file.read()).to_dict()
if lgr_info.is_set:
set_labels_file = form.cleaned_data['set_labels']
if set_labels_file is not None:
# Handle label set
if lgr_info.set_labels_info is None or lgr_info.set_labels_info.name != set_labels_file.name:
lgr_info.set_labels_info = LabelInfo.from_form(set_labels_file.name,
set_labels_file.read())
lgr_json = lgr_info.to_dict()
if not lgr_info.is_set:
annotate_task.delay(lgr_json, labels_json, email_address, storage_path)
else:
script_lgr_id = form.cleaned_data['script']
script_lgr_info = session_select_lgr(request, script_lgr_id, lgr_set_id=lgr_id)
script_lgr_json = script_lgr_info.to_dict()
lgr_set_annotate_task.delay(lgr_json, script_lgr_json, labels_json, email_address, storage_path)
ctx['script'] = script_lgr_id
ctx.update({
'lgr_info': lgr_info,
'labels_file': labels_file.name,
'email': email_address,
'lgr_id': lgr_id if lgr_id is not None else '',
'lgr': lgr_info.lgr if lgr_info is not None else '',
'is_set': lgr_info.is_set if lgr_info is not None else '',
})
return render(request, 'lgr_tools/wait_annotate.html', context=ctx)
ctx = {
'form': form,
'lgr_id': lgr_id if lgr_id is not None else '',
'lgr': lgr_info.lgr if lgr_info is not None else '',
'is_set': lgr_info.is_set if lgr_info is not None else '',
}
return render(request, 'lgr_tools/annotate.html', context=ctx)
def cross_script_variants_task(lgr_json, labels_json, email_address, storage_path):
"""
Compute cross-script variants of labels in a LGR.
:param lgr_json: The LGRInfo as a JSON object.
:param labels_json: The LabelInfo as a JSON object.
:param email_address: The e-mail address where the results will be sent
:param storage_path: The place where results will be stored
"""
lgr_info = LGRInfo.from_dict(lgr_json)
labels_info = LabelInfo.from_dict(labels_json)
logger.info("Starting task 'cross-script variants' for %s, for file %s",
lgr_info.name, labels_info.name)
body = "Hi,\nThe processing of cross-script variants from labels provided in the " \
"file '{f}' in LGR '{lgr}' has".format(f=labels_info.name,
lgr=lgr_info.name)
_lgr_tool_task(storage_path,
base_filename='cross_script_variants_{0}'.format(lgr_info.name),
email_subject='LGR Toolset cross-script variants result',
email_body=body,
email_address=email_address,
cb=lgr_cross_script_variants,
lgr=lgr_info.lgr,
labels_file=labels_info.labels)
def annotate_task(lgr_json, labels_json, email_address, storage_path):
"""
Compute dispositions of labels in a LGR.
:param lgr_json: The LGRInfo as a JSON object.
:param labels_json: The LabelInfo as a JSON object.
:param email_address: The e-mail address where the results will be sent
:param storage_path: The place where results will be stored
"""
lgr = LGRInfo.from_dict(lgr_json).lgr
labels_info = LabelInfo.from_dict(labels_json)
logger.info("Starting task 'annotate' for %s, for file %s",
lgr.name, labels_info.name)
body = "Hi,\nThe processing of annotation from labels provided in the " \
"file '{f}' in LGR '{lgr}' has".format(f=labels_info.name,
lgr=lgr.name)
_lgr_tool_task(storage_path,
base_filename='annotation_{0}'.format(lgr.name),
email_subject='LGR Toolset annotation result',
email_body=body,
email_address=email_address,
cb=lgr_annotate_labels,
lgr=lgr,
labels_file=labels_info.labels)
def collision_task(lgr_json, labels_json, email_address, full_dump,
with_rules, storage_path):
"""
Compute collision between labels in an LGR
:param lgr_json: The LGRInfo as a JSON object.
:param labels_json: The LabelInfo as a JSON object.
:param email_address: The e-mail address where the results will be sent
:param full_dump: Whether we also output a full dump
:param with_rules: Whether we also output rules
:param storage_path: The place where results will be stored
:return:
"""
lgr = LGRInfo.from_dict(lgr_json).lgr
labels_info = LabelInfo.from_dict(labels_json)
logger.info("Starting task 'collision' for %s, for file %s",
lgr.name, labels_info.name)
body = "Hi,\nThe processing of collisions from labels provided in the " \
"file '{f}' in LGR '{lgr}' has".format(f=labels_info.name,
lgr=lgr.name)
_lgr_tool_task(storage_path,
base_filename='collisions_{0}'.format(lgr.name),
email_subject='LGR Toolset collisions result',
email_body=body,
email_address=email_address,
cb=lgr_collision_labels,
lgr=lgr,
labels_file=labels_info.labels,
full_dump=full_dump,
with_rules=with_rules)
def lgr_diff(request, lgr_id):
form = LGRDiffSelector(request.POST or None, request.FILES or None,
session_lgrs=[lgr['name'] for lgr in session_list_lgr(request) if not lgr['is_set']],
lgr_id=lgr_id)
lgr_info = None
if lgr_id is not None:
lgr_info = session_select_lgr(request, lgr_id)
if form.is_valid():
lgr_id_1 = form.cleaned_data['lgr_1']
lgr_id_2 = form.cleaned_data['lgr_2']
labels_file = form.cleaned_data['labels']
email_address = form.cleaned_data['email']
collision = form.cleaned_data['collision']
full_dump = form.cleaned_data['full_dump']
with_rules = form.cleaned_data['with_rules']
lgr_info_1 = session_select_lgr(request, lgr_id_1)
lgr_info_2 = session_select_lgr(request, lgr_id_2)
storage_path = session_get_storage(request)
# need to transmit json serializable data
labels_json = LabelInfo.from_form(labels_file.name,
labels_file.read()).to_dict()
lgr_1_json = lgr_info_1.to_dict()
lgr_2_json = lgr_info_2.to_dict()
diff_task.delay(lgr_1_json, lgr_2_json, labels_json, email_address, collision,
full_dump, with_rules, storage_path)
ctx = {
'lgr_1': lgr_info_1,
'lgr_2': lgr_info_2,
'labels_file': labels_file.name,
'email': email_address,
'lgr_id': lgr_id if lgr_id is not None else '',
'lgr': lgr_info.lgr if lgr_info is not None else '',
'is_set': lgr_info.is_set if lgr_info is not None else '',
}
return render(request, 'lgr_tools/wait_diff.html', context=ctx)
ctx = {
'form': form,
'lgr_id': lgr_id if lgr_id is not None else '',
'lgr': lgr_info.lgr if lgr_info is not None else '',
'is_set': lgr_info.is_set if lgr_info is not None else '',
}
return render(request, 'lgr_tools/diff.html', context=ctx)
def lgr_cross_script_variants(request, lgr_id):
lgr_info = None
if lgr_id is not None:
lgr_info = session_select_lgr(request, lgr_id)
form = _create_set_compatible_form_instance(LGRCrossScriptVariantsSelector,
request, lgr_id)
if form.is_valid():
ctx = {}
lgr_id = form.cleaned_data['lgr']
labels_file = form.cleaned_data['labels']
email_address = form.cleaned_data['email']
lgr_info = session_select_lgr(request, lgr_id)
storage_path = session_get_storage(request)
# need to transmit json serializable data
labels_json = LabelInfo.from_form(labels_file.name,
labels_file.read()).to_dict()
if lgr_info.is_set:
script_lgr_id = form.cleaned_data['script']
script_lgr = session_select_lgr(request, script_lgr_id,
lgr_set_id=lgr_id)
lgr_info = script_lgr
cross_script_variants_task.delay(lgr_info.to_dict(), labels_json,
email_address, storage_path)
ctx.update({
'lgr_info': lgr_info,
'labels_file': labels_file.name,
'email': email_address,
})
return render(request, 'lgr_tools/wait_cross_scripts.html', context=ctx)
ctx = {
'form': form,
'lgr_id': lgr_id if lgr_id is not None else '',
'lgr': lgr_info.lgr if lgr_info is not None else '',
'is_set': lgr_info.is_set if lgr_info is not None else '',
}
return render(request, 'lgr_tools/cross_script_variants.html', context=ctx)
def diff_task(lgr_json_1, lgr_json_2, labels_json, email_address, collision, full_dump,
with_rules, storage_path):
"""
Launch difference computation for a list of labels between two LGR
:param lgr_json_1: The first LGRInfo as a JSON object.
:param lgr_json_2: The second LGRInfo as a JSON object.
:param labels_json: The LabelInfo as a JSON object.
:param email_address: The e-mail address where the results will be sent
:param collision: Whether we also compute collisions
:param full_dump: Whether we also output a full dump
:param with_rules: Whether we also output rules
:param storage_path: The place where results will be stored
:return:
"""
lgr1 = LGRInfo.from_dict(lgr_json_1).lgr
lgr2 = LGRInfo.from_dict(lgr_json_2).lgr
labels_info = LabelInfo.from_dict(labels_json)
logger.info("Starting task 'diff' between %s and %s, for file %s",
lgr1.name, lgr2.name, labels_info.name)
body = "Hi,\nThe processing of diff from labels provided in the " \
"file '{f}' between LGR '{lgr1}' and " \
"LGR '{lgr2}' has".format(f=labels_info.name,
lgr1=lgr1.name,
lgr2=lgr2.name)
_lgr_tool_task(storage_path,
base_filename='diff_{0}_{1}'.format(lgr1.name,
lgr2.name),
email_subject='LGR Toolset diff result',
email_body=body,
email_address=email_address,
cb=lgr_diff_labels,
lgr_1=lgr1, lgr_2=lgr2,
labels_file=labels_info.labels,
show_collision=collision,
full_dump=full_dump,
with_rules=with_rules)
def lgr_set_validate_label_task(lgr_json, script_lgr_json, label, email_address, storage_path):
"""
Compute label validation variants of labels in a LGR.
:param lgr_json: The LGRInfo as a JSON object.
:param script_lgr_json: The LGRInfo for the script used to check label validity as a JSON object.
:param label: The label to validate, as a list of code points.
:param email_address: The e-mail address where the results will be sent
:param storage_path: The place where results will be stored
"""
lgr_info = LGRInfo.from_dict(lgr_json)
udata = get_db_by_version(lgr_info.lgr.metadata.unicode_version)
script_lgr = LGRInfo.from_dict(script_lgr_json).lgr
set_labels_info = lgr_info.set_labels_info
if set_labels_info is None:
set_labels_info = LabelInfo(name='None', labels=[])
logger.info("Starting task 'validate label' for %s, for input label '%s'",
lgr_info.name, label)
u_label = cp_to_ulabel(label)
body = "Hi,\nThe processing of label validation for label '{label}'" \
" in LGR set '{lgr}' with script '{script}' has".format(label=u_label,
lgr=lgr_info.lgr.name,
script=script_lgr.name)
_lgr_tool_task(storage_path,
base_filename='label_validation_{0}'.format(lgr_info.name),
email_subject='LGR Toolset label validation result',
email_body=body,
email_address=email_address,
cb=lgr_set_validate_label,
lgr=lgr_info.lgr,
script_lgr=script_lgr,
set_labels=set_labels_info.labels,
label=label,
udata=udata)
def validate_label(
request,
lgr_id,
lgr_set_id=None,
threshold_include_vars=settings.LGR_VALIDATOR_MAX_VARS_DISPLAY_INLINE,
output_func=None,
noframe=False):
lgr_info = select_lgr(request, lgr_id, lgr_set_id)
udata = get_unidb(lgr_info.lgr.metadata.unicode_version)
scripts = None
if lgr_info.is_set:
scripts = []
for lgr_set_info in lgr_info.lgr_set:
try:
scripts.append((lgr_set_info.name,
lgr_set_info.lgr.metadata.languages[0]))
except (AttributeError, IndexError):
pass
form = ValidateLabelForm(request.POST or request.GET or None,
files=request.FILES or None,
lgr_info=lgr_info,
idna_decoder=udata.idna_decode_label,
scripts=scripts)
ctx = {}
if form.is_bound and form.is_valid():
label_cplist = form.cleaned_data['label']
script_lgr_name = form.cleaned_data.get('script', None)
email = form.cleaned_data['email']
if lgr_info.is_set:
set_labels_file = form.cleaned_data['set_labels']
if set_labels_file is not None:
if lgr_info.set_labels_info is None or lgr_info.set_labels_info.name != set_labels_file.name:
lgr_info.set_labels_info = LabelInfo.from_form(
set_labels_file.name, set_labels_file.read())
try:
ctx = evaluate_label_from_info(
request,
lgr_info,
label_cplist,
script_lgr_name,
email,
threshold_include_vars=threshold_include_vars)
except UnicodeError as ex:
messages.add_message(request, messages.ERROR,
lgr_exception_to_text(ex))
except NeedAsyncProcess:
messages.add_message(
request, messages.INFO,
_('Input label generates too many variants to compute them all quickly. '
'You need to enter your email address and will receive a notification once process is done'
))
ctx['email_required'] = True
except LGRException as ex:
messages.add_message(request, messages.ERROR,
lgr_exception_to_text(ex))
kwargs = {'lgr_id': lgr_id}
if lgr_set_id is not None:
kwargs['lgr_set_id'] = lgr_set_id
# redirect to myself to refresh display
if noframe:
return redirect('lgr_validate_label_noframe', **kwargs)
else:
return redirect('lgr_validate_label', **kwargs)
ctx['form'] = form
ctx['lgr_id'] = lgr_id
ctx['is_set'] = lgr_info.is_set or lgr_set_id is not None
if lgr_set_id:
lgr_set_info = select_lgr(request, lgr_set_id)
ctx['lgr_set'] = lgr_set_info.lgr
ctx['lgr_set_id'] = lgr_set_id
if noframe:
ctx['base_template'] = '_base_noframe.html'
if output_func:
return output_func(ctx)
else:
return render(request, 'lgr_validator/validator.html', context=ctx)