# -*- coding: utf-8 -*-
import locale
from semantics.models import SemanticRole, SemanticFrame, Complement, \
LexicalUnit, FrameRankings, SemanticRolesDisplay, \
LexicalUnitExamples, FramePosition, SelectivePreference, \
RelationalSelectivePreference, SelectivePreferenceRelations, \
GeneralSelectivePreference
from dictionary.models import Frame_Char_Model, Lemma, Lemma_Status, \
sort_arguments, sort_positions, NKJP_Example, \
Frame, Position, Argument
from wordnet.models import Hypernymy, Synonymy, Synset
from dictionary.ajax_lemma_view import user_can_modify
from django.core.exceptions import SuspiciousOperation
from django.core.urlresolvers import reverse
from django.db.models import Q
from datetime import datetime
from django.db.models import Min
from common.decorators import render, ajax, AjaxError
from semantics.change_log import store_old_versions
from semantics.validation import validate_schemas, validate_frames, validate_lexical_units
####################################### render #####################################
@render('semantics.html')
@ajax(method='get', encode_result=False)
def ajax_semantics(request, id):
context = {}
lemma = Lemma.objects.get(id=id, old=False)
context['lemma'] = lemma
context['can_modify'] = (user_can_modify(lemma, request.user) and
lemma.status.stage_of_work.sym_name == 'semantics')
context['js_vars'] = {
'ajax_frames': reverse('ajax_frames'),
'ajax_schemas': reverse('ajax_schemas'),
'ajax_units': reverse('ajax_units'),
'ajax_roles': reverse('ajax_roles'),
'ajax_create_frame': reverse('ajax_create_frame'),
'ajax_create_complement': reverse('ajax_create_complement'),
'ajax_examples': reverse('ajax_examples'),
'ajax_update_meanings': reverse('ajax_update_meanings'),
'ajax_modify_frames': reverse('ajax_modify_frames'),
'ajax_synsets': reverse('ajax_synsets'),
'ajax_relations': reverse('ajax_relations'),
'ajax_predefined_preferences': reverse('ajax_predefined_preferences'),
'ajax_plWN_context_lookup': reverse('ajax_plWN_context_lookup'),
}
return context
def reorder_history(frames_list):
next_ids = set()
for frame in frames_list:
if frame.next is not None:
next_ids.add(frame.next.id)
first = set()
for frame in frames_list:
if frame.id not in next_ids:
first.add(frame)
result = []
for frame in first:
current = frame
while current is not None:
result.append(current)
current = current.next
result.reverse()
return result
@render('frames.json')
@ajax(method='get', encode_result=False)
def ajax_frames(request, lemma_id):
lemma = Lemma.objects.get(id=lemma_id, old=False)
lexical_units = LexicalUnit.objects.filter(Q(base = lemma.entry)|Q(base = lemma.entry + u' się')).order_by('sense')
alternations = {}
frames_dict = {}
frame_units = {}
for lexical_unit in lexical_units:
frames = lexical_unit.actual_frames()
for frame in frames:
alternations[frame.id] = {}
frames_dict[frame.id] = frame
if frame.id not in frame_units:
frame_units[frame.id] = []
frame_units[frame.id].append(lexical_unit)
type_frames = {}
for frame_id in frame_units:
t = tuple(frame_units[frame_id])
if t not in type_frames:
type_frames[t] = []
type_frames[tuple(frame_units[frame_id])].append(frames_dict[frame_id])
frames_display = []
complement_arguments = {}
arguments_frame_connected = {}
for t in type_frames:
type_frames[t] = reorder_history(type_frames[t])
for t in type_frames:
frame_display = {"lexical_units": [], "frames": []}
for lu in list(t):
frame_display["lexical_units"].append({"id": str(lu.id), "base": lu.base, "sense": str(lu.sense)})
for frame in type_frames[t]:
# frame_complements = Complement.objects.filter(frame=frame)
frame_complements = frame.complements.all()
# classes and first frame/position part of identifiers
frame_ids = [u'frame_' + str(frame.id) + '_comp_' + str(complement.id) + '_' for complement in frame_complements]
# names of roles
frame_roles = [{'csv_id': i, 'csv_class': c, 'argument': a} for i, c, a in zip(frame_ids, frame_ids, [[role.id for role in complement.roles.all()] for complement in frame_complements])]
# rowspan for 'Argumenty:'
# frame_preferences_rowspan = max(max([len(preference) for preference in [complement.selective_preference.all() for complement in frame_complements]] + [0]), 1)
frame_preferences_rowspan = max(max([len(complement.selective_preference.generals.all()) + len(complement.selective_preference.synsets.all()) + len(complement.selective_preference.relations.all()) for complement in frame_complements if complement.selective_preference is not None] +[0]), 1)
frame_preferences = []
for i in range(frame_preferences_rowspan):
row = []
idents = []
for frame_id, complement in zip(frame_ids, frame_complements):
if complement.selective_preference is not None:
generals = complement.selective_preference.generals.all()
synsets = complement.selective_preference.synsets.all()
relations = complement.selective_preference.relations.all()
synset_relations = complement.selective_preference.synset_relations.all()
generals_len = len(generals)
synsets_len = len(synsets)
relations_len = len(relations)
synset_relations_len = len(synset_relations)
if generals_len > i:
general = generals[i]
row.append(general.name)
idents.append(frame_id + 'pref_g' + str(general.id) + '_')
elif generals_len + synsets_len > i:
synset = synsets[i - generals_len]
# lexical_units_preference = LexicalUnit.objects.filter(synset=synset)
row.append(unicode(synset))
idents.append(frame_id + 'pref_s' + str(synset.id) + '_')
elif generals_len + synsets_len + relations_len > i:
relation = relations[i - generals_len - synsets_len]
row.append(relation.relation.name + '<br /> -> [' + ', '.join([r.role for r in relation.to.roles.all()]) + ']')
idents.append(frame_id + 'pref_r' + str(relation.id) + '_')
elif generals_len + synsets_len + relations_len + synset_relations_len > i:
relation = relations[i - generals_len - synsets_len - relations_len]
synset = relation.to
row.append(relation.relation.name + '<br /> -> [' + unicode(synset) + ']')
idents.append(frame_id + 'pref_R' + str(relation.id) + '_')
else:
row.append('')
idents.append(frame_id + 'pref_-' + str(i + 1) + '_')
else:
row.append('')
idents.append(frame_id + 'pref_-' + str(i + 1) + '_')
frame_preferences.append([{'csv_id': i, 'csv_class': c, 'preference': p} for i, c, p in zip(idents, frame_ids, row)])
display = {"roles": frame_roles, "preferences": frame_preferences}
frame_display["frames"].append({"frame_id": str(frame.id), "colspan": str(max(len(frame_roles), 1)), "rowspan": str(frame_preferences_rowspan), "status": u'pewna', "display": display})
arguments_frame_connected[frame.id] = []
for complement, complement_class in zip(frame_complements, frame_ids):
if complement_class not in complement_arguments:
complement_arguments[complement_class] = []
for schema_position in complement.realizations.all():
schema = schema_position.frame
position = schema_position.position
argument = schema_position.argument
alternation = schema_position.alternation
realization_id = u'schema_' + str(schema.id) + u'_pos_' + str(position.id) + '_arg_' + str(argument.id) + '_' + 'alt_' + str(alternation) + '_'
complement_arguments[complement_class].append(realization_id)
arguments_frame_connected[frame.id].append(realization_id)
if schema.id in alternations[frame.id]:
alternations[frame.id][schema.id] = max(alternations[frame.id][schema.id], alternation)
else:
alternations[frame.id][schema.id] = alternation
# alternations[frame.id] = {}
frames_display.append(frame_display)
arguments_not_connected = {}
# for complement_class in complement_arguments:
# arguments_not_connected[complement_class] = list(all_schema_classes.difference(arguments_frame_connected[int(complement_class.split('_')[1])]))
# ala["ma"] = "kot"
context = {
'frames_display': frames_display,
'connections': {'connected': complement_arguments, 'disconnected': arguments_not_connected},
'frames_count': lemma.entry_obj.actual_frames().count(),
'alternations': alternations
}
return context
@render('units.json')
@ajax(method='get', encode_result=False)
def ajax_units(request, lemma_id):
lemma = Lemma.objects.get(id=lemma_id, old=False)
lexical_units = LexicalUnit.objects.filter(Q(base = lemma.entry, pos="czasownik")|Q(base = lemma.entry + u' się', pos="czasownik")).order_by('base', 'sense')
context = {
'lexical_units': [{"id": lu.id, "luid": lu.luid, "base": lu.base, "sense": lu.sense, "pos": lu.pos, "glossa": lu.glossa, "definition": lu.definition} for lu in lexical_units],
'informations': {'base': lemma.entry, 'sense': max(['A'] + [chr(ord(lu.sense) + 1) for lu in lexical_units.filter(luid=-1)])}, # TODO: 2 different free senses for with/whthout 'się'
}
return context
@ajax(method='get')
def ajax_predefined_preferences(request):
predefined = []
for preference in GeneralSelectivePreference.objects.order_by('name'):
if preference.members:
members = [member.name for member in preference.members.generals.order_by('name')]
members.extend([unicode(synset) for synset in preference.members.synsets.all()])
content = u'%s: (%s)' % (preference.name, ', '.join(members))
else:
content = u'%s' % (preference.name)
predefined.append({"id": preference.id, "content": content})
context = {
'predefined': predefined,
}
return context
@render('synsets.json')
@ajax(method='get', encode_result=False)
def ajax_synsets(request, base, pos):
if pos == '_':
lexical_units = LexicalUnit.objects.filter(base=base).order_by('pos', 'base', 'sense')
else:
lexical_units = LexicalUnit.objects.filter(base=base, pos=pos).order_by('pos', 'base', 'sense')
synsets = []
for representative in lexical_units:
synset = [{"id": lu.id, "luid": lu.luid, "base": lu.base, "sense": lu.sense, "pos": lu.pos, "glossa": lu.definition} for lu in LexicalUnit.objects.filter(synset=representative.synset)]
synsets.append({"id": representative.synset.id, "content": synset})
context = {
'synsets': synsets,
}
return context
@render('relations.json')
@ajax(method='get', encode_result=False)
def ajax_relations(request):
relations = [{"id": relation.id, "content": relation.name} for relation in SelectivePreferenceRelations.objects.all()]
context = {
'relations': relations,
}
return context
@render('roles.json')
@ajax(method='get', encode_result=False)
def ajax_roles(request):
roles_display = []
maxrow = SemanticRolesDisplay.objects.all().order_by('-row')[0].row
for i in range(1, maxrow + 1):
row = []
cells = SemanticRolesDisplay.objects.filter(row=i).order_by('column')
for cell in cells:
content = cell.roles.all().order_by('id')
commas = [','] * max(len(content) - 1, 0) + ['']
row.append((cell.caption, cell.rowspan, cell.colspan, zip(content, commas)))
commas = [','] * max(len(row) - 1, 0) + ['']
captions, rowspans, colspans, contents = zip(*row)
roles_display.append(zip(list(captions), list(rowspans), list(colspans), list(contents), commas))
commas = [','] * max(len(roles_display) - 1, 0) + ['']
context = {
'roles_display': zip(roles_display, commas),
}
return context
@render('schemas.json')
@ajax(method='get', encode_result=False)
def ajax_schemas(request, lemma_id):
lemma = Lemma.objects.get(id=lemma_id, old=False)
schemas_all = lemma.frames.all()
characteristics = {}
characteristics_ids = []
schemas_by_characteristic = {}
for schema in schemas_all:
chars = schema.characteristics.all()
char_types = [c.type for c in chars]
l = [(Frame_Char_Model.objects.get(model_name=c.type).priority, c) for c in chars]
l.sort()
_, chars = zip(*l)
chars = list(chars)
characteristic_id = tuple([char.id for char in chars])
if characteristic_id not in characteristics:
characteristics_ids.append(characteristic_id)
values = [char.value.value for char in chars]
if values[0]:
characteristics[characteristic_id] = "%s (%s)" % (values[0], ','.join(values[1:]))
else:
characteristics[characteristic_id] = "(%s)" % (','.join(values[1:]))
schemas_by_characteristic[characteristic_id] = []
schemas_by_characteristic[characteristic_id].append(schema)
lexical_units = LexicalUnit.objects.filter(Q(base=lemma.entry) | Q(base=lemma.entry+u' się'))
schemas_display = []
schema_unit_rank = {}
for characteristic_id in characteristics_ids:
schema_display = {"characteristic_id": '_'.join([str(i) for i in characteristic_id]), "characteristic_display": characteristics[characteristic_id], "schemas": []}
schemas = schemas_by_characteristic[characteristic_id]
for schema in schemas: # row by row display for schema tables
ordered_positions = sort_positions(schema.positions.all())
# classes and first frame/position part of identifiers
schema_ids = [u'schema_' + str(schema.id) + '_pos_' + str(position.id) + '_' for position in ordered_positions]
# names of categories (along with class names
schema_categories = zip(schema_ids, [','.join([category.category for category in position.ordered_categories()]) for position in ordered_positions])
# value of rowspan for 'Argumenty:' header
schema_arguments_rowspan = max(max([position.arguments.count() for position in ordered_positions] + [0]), 1)
display = {"categories": [{"csv_id": c, "csv_class": c, "argument": a} for c, a in schema_categories], "arguments": []}
for i in range(schema_arguments_rowspan):
row = []
idents = []
for schema_id, position in zip(schema_ids, ordered_positions):
if position.arguments.count() > i:
ordered_arguments = sort_arguments(position.arguments.all())
row.append(unicode(ordered_arguments[i]))
idents.append(schema_id + 'arg_' + str(ordered_arguments[i].id) + '_')
else: # this category has fewer posible argument realizations
row.append('')
idents.append(schema_id + 'arg_-' + str(i + 1) + '_')
# identifier, class, argument
display["arguments"].append([{"csv_id": i, "csv_class": c, "argument": a} for i, c, a in zip(idents, schema_ids, row)])
schema_display["schemas"].append({"schema_id": str(schema.id), "grade": lemma.get_schema_opinion(schema), "colspan": str(max(len(schema_categories), 1)), "rowspan": str(schema_arguments_rowspan), "display": display, "phraseologic": schema.phraseologic})
ranks = FrameRankings.objects.filter(frame=schema)
for rank in ranks:
if rank.lexical_unit.id not in schema_unit_rank:
schema_unit_rank[rank.lexical_unit.id] = {}
schema_unit_rank[rank.lexical_unit.id]["schema_" + str(schema.id) + "_"] = str(rank.rank)
schemas_display.append(schema_display)
context = {
'lemma': lemma,
'schemas_display': schemas_display,
'ranks': schema_unit_rank
}
return context
@render('examples.json')
@ajax(method='get', encode_result=False)
def ajax_examples(request, lemma_id):
lemma = Lemma.objects.get(id=lemma_id, old=False)
nkjp_examples = lemma.nkjp_examples.all()
lexical_units = LexicalUnit.objects.filter(Q(base = lemma.entry)|Q(base = lemma.entry + u' się'))
lexical_units_ids = [lu.id for lu in lexical_units]
examples_linked = []
for nkjp_example in nkjp_examples:
linked = LexicalUnitExamples.objects.filter(example=nkjp_example)
meanings = []
for link in linked:
if link.lexical_unit.id in lexical_units_ids:
meanings.append(link.lexical_unit.id)
all_argselection = nkjp_example.arguments.all()
arguments = []
for argselection in all_argselection:
pos = argselection.position.id
args = argselection.arguments.all()
for arg in args:
arguments.append({'id': 'schema_' + str(nkjp_example.frame.id) + '_pos_' + str(pos) + '_arg_' + str(arg.id) + '_'})
examples_linked.append({'schema': 'schema_' + str(nkjp_example.frame.id) + '_', 'arguments': arguments, 'id': nkjp_example.id, 'sentence': nkjp_example.sentence, 'source': nkjp_example.source.source, 'opinion': nkjp_example.opinion.opinion, 'meanings': meanings})
context = {
'examples': examples_linked
}
return context
@ajax(method='get', encode_result=False)
def ajax_create_frame(request, lexical_units):
#lexical_unit_id_list = request.GET.get('lexical_units', '')
lexical_unit_id_list = lexical_units
lexical_units_ids = [int(id) for id in lexical_unit_id_list.split(',')]
lexical_units = []
for lexical_unit_id in lexical_units_ids:
lexical_units.append(LexicalUnit.objects.get(id=lexical_unit_id))
unit_bases = [lexical_unit.base for lexical_unit in lexical_units]
base = unit_bases[0].split(' ')[0]
for unit_base in unit_bases:
if unit_base != base and unit_base != base + u' się':
raise SuspiciousOperation
frame = SemanticFrame()
frame.save()
for lexical_unit in lexical_units:
frame.lexical_units.add(lexical_unit)
lemma = Lemma.objects.get(entry=lexical_unit.base, old=False)
return ajax_frames(request, lemma.id)
@ajax(method='get', encode_result=False)
def ajax_create_complement(request, lemma_id, frame, roles):
#lemma_id = int(request.GET.get('lemma_id', ''))
lemma = Lemma.objects.get(id=lemma_id, old=False)
frame_id = frame
#frame_id = int(request.GET.get('frame', ''))
frame = SemanticFrame.objects.get(id=frame_id)
#role_id_list = request.GET.get('roles', '')
role_id_list = roles
role_ids = [int(id) for id in role_id_list.split(',')]
roles = []
for role_id in role_ids:
roles.append(SemanticRole.objects.get(id=role_id))
complement = Complement(frame=frame)
complement.save()
for role in roles:
complement.roles.add(role)
return ajax_frames(request, lemma.id)
@ajax(method='get', encode_result=False)
def ajax_update_meanings(request, operations, lemma_id):
translation = {}
for operation in operations:
if operation['operation'] == "set_glossa":
if int(operation['unit']) in translation:
unit = translation[int(operation['unit'])]
else:
unit = int(operation['unit'])
set_glossa(unit, operation['value'])
elif operation['operation'] == "add_example":
if int(operation['unit']) in translation:
unit = translation[int(operation['unit'])]
else:
unit = int(operation['unit'])
add_example(unit, operation['example'])
elif operation['operation'] == "remove_example":
if int(operation['unit']) in translation:
unit = translation[int(operation['unit'])]
else:
unit = int(operation['unit'])
remove_example(unit, operation['example'])
elif operation['operation'] == "add_unit":
translation[operation['unit']['id']] = add_unit(operation['unit'])
elif operation['operation'] == "remove_unit":
luid = int(operation['luid'])
if luid in translation:
remove_unit(translation[luid])
else:
remove_unit(luid)
else:
pass
return ajax_units(request)
def set_glossa(unit_id, new_glossa):
unit = LexicalUnit.objects.get(id=unit_id)
unit.glossa = new_glossa
unit.save()
def add_example(unit_id, example_id):
unit = LexicalUnit.objects.get(id=unit_id)
nkjp_example = NKJP_Example.objects.get(id=example_id)
lue = LexicalUnitExamples(example=nkjp_example, lexical_unit=unit)
lue.save()
def remove_example(unit_id, example_id):
unit = LexicalUnit.objects.get(id=unit_id)
nkjp_example = NKJP_Example.objects.get(id=example_id)
lue = LexicalUnitExamples.objects.get(example=nkjp_example, lexical_unit=unit)
lue.delete()
def add_unit(unit): # returns new id
s1 = Synset(id=(min(Synset.objects.all().aggregate(Min('id'))['id__min'], 0) - 1))
s1.save()
lu = LexicalUnit(base=unit['base'], sense=unit['sense'], pos=unit['pos'], glossa=unit['glossa'], luid=-1, synset=s1)
lu.save()
if int(unit['relation']) == 1:
s2 = Synset.objects.get(id=int(unit['to']))
r = Synonymy(parent=s1, child=s2)
r.save()
r = Synonymy(parent=s2, child=s1)
r.save()
elif int(unit['relation']) == 0:
s2 = Synset.objects.get(id=int(unit['to']))
r = Hypernymy(parent=s1, child=s2)
r.save()
else:
pass
return lu.id
def remove_unit(luid):
lu = LexicalUnit.objects.get(id=luid)
if lu.luid is not None and lu.luid >= 0:
return
else:
lu.delete()
@ajax(method='get', encode_result=False)
def ajax_modify_frames(request, operations, lemma_id):
if not request.user.is_authenticated():
return 'user logged out'
store_old_versions(lemma_id, operations, request.user)
translation = {'frame_id': {}, 'complement_id': {}, 'preference_id': {}}
for operation in operations:
if operation['operation'] == "create_frame":
luids = [int(m['id']) for m in operation['meanings']]
translation['frame_id'][int(operation['id'])] = create_frame(luids)
elif operation['operation'] == "remove_frame":
if int(operation['id']) in translation['frame_id']:
frame_id = translation['frame_id'][int(operation['id'])]
else:
frame_id = int(operation['id'])
remove_frame(frame_id)
elif operation['operation'] == "add_argument":
if int(operation['frame_id']) in translation['frame_id']:
frame_id = translation['frame_id'][int(operation['frame_id'])]
else:
frame_id = int(operation['frame_id'])
roles = [int(r) for r in operation['role']]
translation['complement_id'][int(operation['id'])] = add_argument(frame_id, roles)
elif operation['operation'] == "remove_argument":
if int(operation['frame_id']) in translation['frame_id']:
frame_id = translation['frame_id'][int(operation['frame_id'])]
else:
frame_id = int(operation['frame_id'])
if int(operation['complement_id']) in translation['complement_id']:
complement_id = translation['complement_id'][int(operation['complement_id'])]
else:
complement_id = int(operation['complement_id'])
remove_argument(frame_id, complement_id)
elif operation['operation'] == "connect":
frame_data = operation['arg'].split('_')
if int(frame_data[1]) in translation['frame_id']:
frame_id = translation['frame_id'][int(frame_data[1])]
else:
frame_id = int(frame_data[1])
if int(frame_data[3]) in translation['complement_id']:
complement_id = translation['complement_id'][int(frame_data[3])]
else:
complement_id = int(frame_data[3])
schema_data = operation['connect'].split('_')
schema_id = int(schema_data[1])
position_id = int(schema_data[3])
argument_id = int(schema_data[5])
alternation = int(schema_data[7])
connect(frame_id, complement_id, schema_id, position_id, argument_id, alternation)
elif operation['operation'] == "disconnect":
frame_data = operation['arg'].split('_')
if int(frame_data[1]) in translation['frame_id']:
frame_id = translation['frame_id'][int(frame_data[1])]
else:
frame_id = int(frame_data[1])
if int(frame_data[3]) in translation['complement_id']:
complement_id = translation['complement_id'][int(frame_data[3])]
else:
complement_id = int(frame_data[3])
schema_data = operation['connect'].split('_')
schema_id = int(schema_data[1])
position_id = int(schema_data[3])
argument_id = int(schema_data[5])
alternation = int(schema_data[7])
disconnect(frame_id, complement_id, schema_id, position_id, argument_id, alternation)
elif operation['operation'] == "assign_role":
if int(operation['frame_id']) in translation['frame_id']:
frame_id = translation['frame_id'][int(operation['frame_id'])]
else:
frame_id = int(operation['frame_id'])
if int(operation['complement_id']) in translation['complement_id']:
complement_id = translation['complement_id'][int(operation['complement_id'])]
else:
complement_id = int(operation['complement_id'])
roles = [int(r) for r in operation['role']]
assign_role(frame_id, complement_id, roles)
elif operation['operation'] == "change_units":
if int(operation['frame_id']) in translation['frame_id']:
frame_id = translation['frame_id'][int(operation['frame_id'])]
else:
frame_id = int(operation['frame_id'])
luids = [int(m) for m in operation['units']]
change_units(frame_id, luids)
elif operation['operation'] == "add_preference":
# {operation: 'add_preference', frame_id: frame_id, complement_id: complement_id, preference_id: preference_id, preference: preference}
if int(operation['frame_id']) in translation['frame_id']:
frame_id = translation['frame_id'][int(operation['frame_id'])]
else:
frame_id = int(operation['frame_id'])
if int(operation['complement_id']) in translation['complement_id']:
complement_id = translation['complement_id'][int(operation['complement_id'])]
else:
complement_id = int(operation['complement_id'])
preference_id = add_preference(frame_id, complement_id, operation['preference']['type'], operation['preference']['content'])
translation['preference_id'][operation['preference_id']] = preference_id
elif operation['operation'] == "remove_preference":
# {operation: 'remove_preference', frame_id: frame_id, complement_id: complement_id, preference_id: preference_id}
if int(operation['frame_id']) in translation['frame_id']:
frame_id = translation['frame_id'][int(operation['frame_id'])]
else:
frame_id = int(operation['frame_id'])
if int(operation['complement_id']) in translation['complement_id']:
complement_id = translation['complement_id'][int(operation['complement_id'])]
else:
complement_id = int(operation['complement_id'])
if operation['preference_id'] in translation['preference_id']:
preference_id = translation['preference_id'][operation['preference_id']]
else:
preference_id = (operation['preference_id'][0], int(operation['preference_id'][1:]))
remove_preference(frame_id, complement_id, preference_id)
else:
pass
return ajax_frames(request)
def create_frame(luids):
frame = SemanticFrame()
frame.save()
for id in luids:
lu = LexicalUnit.objects.get(id=id)
frame.lexical_units.add(lu)
return frame.id
def change_units(frame_id, luids):
frame = SemanticFrame.objects.get(id=frame_id)
frame.lexical_units = []
for id in luids:
lu = LexicalUnit.objects.get(id=id)
frame.lexical_units.add(lu)
def remove_frame(frame_id):
frame = SemanticFrame.objects.get(id=frame_id)
frame.removed = True
frame.save()
def add_argument(frame_id, roles):
if validate_roles(roles):
frame = SemanticFrame.objects.get(id=frame_id)
complement = Complement(frame=frame)
complement.save()
frame.complements.add(complement)
role_objects = []
for r in roles:
role_objects.append(SemanticRole.objects.get(id=r))
complement.roles = role_objects
return complement.id
def remove_argument(frame_id, complement_id):
Complement.objects.get(id=complement_id).delete()
def connect(frame_id, complement_id, schema_id, position_id, argument_id, alternation):
schema = Frame.objects.get(id=schema_id)
position = Position.objects.get(id=position_id)
argument = Argument.objects.get(id=argument_id)
fpas = FramePosition.objects.filter(frame=schema, position=position, argument=argument, alternation=alternation)
if len(fpas) > 0:
fpa = fpas[0]
else:
fpa = FramePosition(frame=schema, position=position, argument=argument, alternation=alternation)
fpa.save()
complement = Complement.objects.get(id=complement_id)
complement.realizations.add(fpa)
def disconnect(frame_id, complement_id, schema_id, position_id, argument_id, alternation):
schema = Frame.objects.get(id=schema_id)
position = Position.objects.get(id=position_id)
argument = Argument.objects.get(id=argument_id)
fpas = FramePosition.objects.filter(frame=schema, position=position, argument=argument, alternation=alternation)
if len(fpas) > 0:
fpa = fpas[0]
else:
return
complement = Complement.objects.get(id=complement_id)
complement.realizations.remove(fpa)
def assign_role(frame_id, complement_id, roles):
if validate_roles(roles):
role_objects = []
for r in roles:
role_objects.append(SemanticRole.objects.get(id=r))
complement = Complement.objects.get(id=complement_id)
complement.roles = role_objects
def validate_roles(roles):
role_objects = []
for r in roles:
role_objects.append(SemanticRole.objects.get(id=r))
if len(role_objects) > 2:
return False
ok = False
for r in role_objects:
if not r.color == None:
ok = not ok
return ok
# preference_id = add_preference(frame_id, complement_id, operation['preference']['type'], operation['preference']['content'])
def add_preference(frame_id, complement_id, preference_type, preference_content):
complement = Complement.objects.get(id=complement_id)
if complement.selective_preference is None:
sp = SelectivePreference()
sp.save()
complement.selective_preference = sp
complement.save()
if preference_type == 'g':
general = GeneralSelectivePreference.objects.get(id=int(preference_content))
complement.selective_preference.generals.add(general)
return ('g', general.id)
elif preference_type == 's':
synset = Synset.objects.get(id=int(preference_content))
complement.selective_preference.synsets.add(synset)
return ('s', synset.id)
elif preference_type == 'r':
relation = SelectivePreferenceRelations.objects.get(id=int(preference_content['relation']))
argument = [int(a) for a in preference_content['to'].split(',')]
frame = SemanticFrame.objects.get(id=frame_id)
candidates = Complement.objects.filter(frame=frame)
found = None
for c in candidates:
if len(c.roles.all()) == len(argument):
roles = [r.id for r in c.roles.all()]
ok = True
for a in argument:
if a not in roles:
ok = False
if ok:
found = c
break
if found is not None:
rsp = RelationalSelectivePreference(relation=relation, to=found)
rsp.save()
complement.selective_preference.relations.add(rsp)
return ('r', rsp.id)
else:
return -1
else:
return -1
# remove_preference(frame_id, complement_id, preference)
def remove_preference(frame_id, complement_id, preference):
preference_type, preference_id = preference
if preference_type == 'g':
complement = Complement.objects.get(id=complement_id)
g = complement.selective_preference.generals.get(id = int(preference_id))
complement.selective_preference.generals.remove(g)
elif preference_type == 's':
complement = Complement.objects.get(id=complement_id)
s = complement.selective_preference.synsets.get(id = int(preference_id))
complement.selective_preference.synsets.remove(s)
elif preference_type == 'r':
complement = Complement.objects.get(id=complement_id)
r = complement.selective_preference.relations.get(id = int(preference_id))
complement.selective_preference.relations.remove(r)
@ajax(method='get', encode_result=True)
def ajax_plWN_context_lookup(request, term):
results = []
if len(term) > 0:
obj_results = LexicalUnit.objects.filter(base__startswith=term)
results = get_ordered_lexical_units_bases(obj_results)
return {'result': results}
def get_ordered_lexical_units_bases(lexical_units_query):
last_unit_base = ''
lexical_unit_bases = []
ordered_lexical_units = lexical_units_query.order_by('base')
for lexical_unit in ordered_lexical_units:
if lexical_unit.base != last_unit_base:
lexical_unit_bases.append(lexical_unit.base)
last_unit_base = lexical_unit.base
return lexical_unit_bases
@ajax(method='get')
def validate_semantics(request, lemma_id, new_status_id):
error_msg = ''
try:
status = Lemma_Status.objects.get(id=new_status_id)
except Lemma_Status.DoesNotExist:
status = None
if status and status.check_semantics:
error_msg = validate_frames(lemma_id)
if not error_msg:
error_msg = validate_lexical_units(lemma_id)
if not error_msg:
error_msg = validate_schemas(lemma_id)
return {'error_message': error_msg}