saving.py
6.33 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
# -*- coding: utf-8 -*-
from common.js_to_obj import jsPosToObj
from dictionary.models import Argument
from semantics.models import Complement, LexicalUnitExamples
from semantics.saving import modify_frames, update_meanings
from wordnet.models import LexicalUnit
def get_semantic_operations(lemma, schemata_conversions):
connections = []
operations = []
# frames = lemma.entry_obj.actual_frames()
frames = lemma.entry_obj.actual_frames()
for entry in lemma.entry_obj.rel_entries.all():
new_frames = entry.actual_frames()
frames |= new_frames
for conv in schemata_conversions:
schema_operations = get_reconnect_operations_and_extend_connections(frames,
connections,
conv['obj'],
conv['js'])
operations.extend(schema_operations)
operations.extend(get_disconnect_operations(lemma, frames, connections))
return operations
def get_reconnect_operations_and_extend_connections(frames, connections, schema, js_schema):
operations = []
used_poss_ids = []
for js_position in js_schema['positions']:
if len(js_position['arguments']) > 0:
position = get_position(schema, js_position, used_poss_ids)
for js_phrase_type in js_position['arguments']:
phrase_type = Argument.objects.get(text_rep=js_phrase_type['text_rep'])
new_connection_target = {'schema': schema,
'position': position,
'phrase_type': phrase_type}
for conn in js_phrase_type['connections']:
operations.extend(reconnect_operations(frames, conn, new_connection_target))
conn_dict = next((conn_dict
for conn_dict in connections if conn_dict['compl'] == conn['compl']), None)
if conn_dict:
conn_dict['realizations'].extend(conn['realizations'])
else:
connections.append({'compl': conn['compl'],
'realizations': conn['realizations']})
return operations
def get_position(schema, js_position, used_poss_ids):
position = jsPosToObj(js_position)
same_poss = schema.positions.filter(text_rep=position.text_rep)
unused_same_poss = same_poss.exclude(id__in=used_poss_ids).order_by('id')
position = unused_same_poss[0]
used_poss_ids.append(position.id)
return position
def reconnect_operations(frames, connection, new_target):
operations = []
compl = Complement.objects.get(id=connection['compl'])
frame = frames.get(complements=compl)
arg_ref = create_argument_ref(frame, compl)
for real_id in connection['realizations']:
realization = compl.realizations.get(id=real_id)
old_phrase_type_ref = create_phrase_type_ref(realization.frame, realization.position,
realization.argument, realization.alternation)
new_phrase_type_ref = create_phrase_type_ref(new_target['schema'], new_target['position'],
new_target['phrase_type'], realization.alternation)
if new_phrase_type_ref != old_phrase_type_ref:
operations.append(create_operation('disconnect', arg_ref, old_phrase_type_ref))
operations.append(create_operation('connect', arg_ref, new_phrase_type_ref))
return operations
def create_argument_ref(frame, complement):
return 'frame_%d_comp_%d_' % (frame.id, complement.id)
def create_phrase_type_ref(schema, position, phrase_type, alternation):
return 'schema_%d_pos_%d_arg_%d_alt_%d_' % (schema.id, position.id,
phrase_type.id, alternation)
def create_operation(operation, arg_ref, phrase_type_ref):
return {'operation': operation, 'arg': arg_ref, 'connect': phrase_type_ref}
def get_disconnect_operations(lemma, frames, connections):
operations = []
shared_schemata_ids = get_shared_schemata_ids(lemma)
for frame in frames:
for compl in frame.complements.all():
conn_dict = next((conn_dict
for conn_dict in connections if conn_dict['compl'] == compl.id), None)
for real in compl.realizations.all():
if real.frame.id not in shared_schemata_ids:
if not conn_dict or not real.id in conn_dict['realizations']:
phrase_type_ref = create_phrase_type_ref(real.frame, real.position,
real.argument, real.alternation)
arg_ref = create_argument_ref(frame, compl)
operations.append(create_operation('disconnect', arg_ref, phrase_type_ref))
return operations
def get_shared_schemata_ids(lemma):
print lemma
ids = [f.id for f in lemma.frames.all()]
print ids
for connected in lemma.entry_obj.rel_entries.all():
ids += [f.id for f in connected.actual_lemma().frames.all()]
print ids
return ids
def update_connections(lemma_id, reconnect_operations, user):
modify_frames(lemma_id, reconnect_operations, user)
def disconnect_all_examples_operations(lemma):
operations = []
lex_units = lemma.entry_obj.meanings.all()
for lu in lex_units:
lu_examples = LexicalUnitExamples.objects.filter(lexical_unit=lu)
for lu_ex in lu_examples:
example = lu_ex.example
operations.append({'operation': 'remove_example',
'unit': lu.id,
'example': example.id})
return operations
def connect_example_operation(example_dict, example_obj):
lu = LexicalUnit.objects.get(id=example_dict['lexical_unit'])
return {'operation': 'add_example', 'unit': lu.id, 'example': example_obj.id}
def disconnect_example_operation(example_dict, example_obj):
lu = LexicalUnit.objects.get(id=example_dict['lexical_unit'])
return {'operation': 'remove_example', 'unit': lu.id, 'example': example_obj.id}
def reconnect_examples(lemma, operations):
update_meanings(lemma.id, operations)