def errors_for_class(frameset, ladl, lvf):
"""
Lists framesets without any translation from LADL or LVF.
We start with the root frameset then go on with children. This allows us to
keep track of LVF and LADL strings: indeed, those get inherited from their
parents.
"""
if frameset.removed:
return []
errors = []
try:
members = [member.lemma for member in frameset.verbnetmember_set.all()]
if members:
final_translations = translations_for_class(members, ladl, lvf)
ladl_verbs = [t for t in final_translations if t[1] in ['ladl', 'both']]
lvf_verbs = [t for t in final_translations if t[1] in ['lvf', 'both']]
if ladl and not ladl_verbs:
errors.append((frameset.name, url_of_fs(frameset), 'ladl', ladl, ", ".join(members)))
if lvf and not lvf_verbs:
errors.append((frameset.name, url_of_fs(frameset), 'lvf', lvf, ", ".join(members)))
except UnknownErrorException as e:
mail_managers('Error was in {}'.format(frameset.name), message='')
for child in frameset.children.filter(removed=False):
new_ladl = ladl if not child.ladl_string else child.ladl_string
new_lvf = lvf if not child.lvf_string else child.lvf_string
errors.extend(errors_for_class(child, new_ladl, new_lvf))
return errors
def update_translations_aux(self, ladl_string, lvf_string):
"""
Updates translations given members in class and ladl_string/lvf_string
parameters.
ladl_string and lvf_string can be different from self.ladl_string and
self.lvf_string if we're using an inherited lvf or ladl string, eg. if
the current node's string is unset but his parent's string is set.
If you're modifying this function, look at tools.views.errors_for_class
too which also uses the ladl/lvf inheritance logic."""
def in_parents(frameset, french, categoryname):
for parent_frameset in frameset.get_parents():
for translation in parent_frameset.verbtranslation_set.all():
if translation.verb == french:
#assert categoryname in ['unknown', 'dicovalence'] and translation.category in ['ladl', 'lvf', 'both']
return True
return False
translations_in_subclasses = []
for db_childrenfs in self.children.filter(removed=False):
new_ladl = ladl_string if not db_childrenfs.ladl_string else db_childrenfs.ladl_string
new_lvf = lvf_string if not db_childrenfs.lvf_string else db_childrenfs.lvf_string
translations_in_subclasses.extend(db_childrenfs.update_translations_aux(ladl_string=new_ladl, lvf_string=new_lvf))
initial_set = {(v.verb, v.category, v.validation_status) for v in self.verbtranslation_set.all()}
moved_set = set()
inferred_verbs = self.verbtranslation_set.filter(validation_status=VerbTranslation.STATUS_INFERRED)
inferred_verbs.delete()
manually_validated_verbs = self.verbtranslation_set.exclude(validation_status=VerbTranslation.STATUS_INFERRED)
manually_validated_set = {v.verb: v.category for v in manually_validated_verbs}
when_deleted = strftime("%d/%m/%Y %H:%M:%S", gmtime())
members = [m.lemma for m in self.verbnetmember_set.all()]
candidates = translations_for_class(members, ladl_string, lvf_string)
verb_logger = logging.getLogger('verbs')
for french, categoryname, category_id, originlist in candidates:
originset = set(originlist.split(','))
if set(members) & originset: # is actually a translation
# At this point we have four options.
# 1/ this translation was added below but hidden: we can show
# it here unhidden, which is better.
same_verb_below_list = [v for v in translations_in_subclasses if v.verb == french]
if same_verb_below_list:
for same_verb_below in same_verb_below_list:
# Don't touch validated verbs
if same_verb_below.validation_status != VerbTranslation.STATUS_INFERRED:
continue
if categoryname in ['ladl', 'lvf', 'both'] and same_verb_below.category in ['dicovalence', 'unknown']:
previous_subclass = same_verb_below.frameset
previous_category = same_verb_below.category
same_verb_below.frameset = self
same_verb_below.category = categoryname
same_verb_below.category_id = VerbTranslation.CATEGORY_ID[categoryname]
same_verb_below.save()
moved_set.add((same_verb_below.verb, same_verb_below.category, same_verb_below.validation_status))
translations_in_subclasses = [v for v in translations_in_subclasses if v.verb != french]
verb_logger.info("{}: Moved {} up from subclass {} to subclass {} ({} -> {}).".format(
when_deleted, french, previous_subclass.name, self.name, previous_category, categoryname))
# 2/ this translation was not manually validated at all: add it
elif french not in manually_validated_set:
# Make sure not to add a verb that was already moved up to
# parents in a previous run
if not (in_parents(self, french, categoryname) and categoryname in ['unknown', 'dicovalence']):
VerbTranslation(
frameset=self, verb=french, origin=originlist,
category=categoryname,
category_id=VerbTranslation.CATEGORY_ID[categoryname]).save()
# 3/ this translation was manually validated but with a different
# status: change the status
elif categoryname != manually_validated_set[french]:
verb_to_update = VerbTranslation.objects.get(
frameset=self, verb=french, category=manually_validated_set[french])
verb_to_update.category = categoryname
verb_to_update.category_id = VerbTranslation.CATEGORY_ID[categoryname]
verb_to_update.save()
# 4/ this translation was manually validated and already has
# the correct color: do nothing
else:
pass
when_added = strftime("%d/%m/%Y %H:%M:%S", gmtime())
verbs = self.verbtranslation_set.all()
final_set = {(v.verb, v.category, v.validation_status) for v in verbs}
if initial_set - final_set:
verb_logger.info("{}: Removed verbs in subclass {}: {}".format(
when_deleted, self.name, ", ".join(["{} ({}, {})".format(v, c, s) for v, c, s in sorted(initial_set - final_set, key=lambda vcs: vcs[0])])))
if (final_set - initial_set) - moved_set: # parens for clarity only
verb_logger.info("{}: Added verbs in subclass {}: {}".format(
when_deleted, self.name, ", ".join(["{} ({}, {})".format(v, c, s) for v, c, s in sorted(final_set - initial_set, key=lambda vcs: vcs[0])])))
return list(verbs) + translations_in_subclasses
