validation.py
7.59 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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
# -*- coding: utf-8 -*-
from django.db.models import Max
from dictionary.models import Lemma, reflex_phrase_types
from semantics.models import LexicalUnitExamples
from semantics.utils import get_matching_frame
def validate_frames(lemma_id):
lemma = Lemma.objects.get(id=lemma_id, old=False)
actual_frames = lemma.entry_obj.actual_frames()
error_msg = u''
for frame in actual_frames.all():
error_msg = frame_valid(lemma, frame, actual_frames)
if error_msg:
break
return error_msg
def frame_valid(lemma, frame, actual_frames):
error_msg = ''
complements = frame.complements.all()
if not arguments_exists(complements):
error_msg = u'Semantyka: Rama semantyczna %d jest pusta.' % frame.id
elif not roles_unique(complements):
error_msg = u'Semantyka: Rama semantyczna %d nie zawiera unikalnych ról.' % frame.id
elif not arguments_pinned(complements):
error_msg = u'Semantyka: Rama semantyczna %d zawiera argumenty, które nie są powiązane z żadnym schematem.' % frame.id
elif not preferences_selected(complements):
error_msg = u'Semantyka: Rama semantyczna %d zawiera argumenty bez zdefiniowanych preferencji selekcyjnych.' % frame.id
elif not examples_added(frame):
error_msg = u'Semantyka: Rama semantyczna %d nie ma dopiętych przykładów.' % frame.id
elif duplicates_exists(frame, actual_frames):
error_msg = u'Semantyka: Rama semantyczna %d posiada duplikaty.' % frame.id
elif not schemas_reflex_agreed(lemma, frame):
error_msg = u'Semantyka: Rama semantyczna %d ma dopięte elementy o niezgodnej zwrotności.' % frame.id
elif nonch_pinned(frame):
error_msg = u'Semantyka: Rama semantyczna %d jest dopięta do typu frazy nonch.' % frame.id
elif multiplied_same_arg_in_schema(frame):
error_msg = u'Semantyka: Rama semantyczna %d posiada argument wielokrotnie powiązany z tym samym schematem.' % frame.id
return error_msg
def arguments_exists(complements):
return complements.exists()
def roles_unique(complements):
roles = set()
for complement in complements:
role_ids = [role.id for role in complement.roles.all()]
role_ids.sort()
role = tuple(role_ids)
if role in roles:
return False
else:
roles.add(role)
return True
def arguments_pinned(complements):
for compl in complements:
if not compl.realizations.exists():
return False
return True
def preferences_selected(complements):
for complement in complements:
if not preference_valid(complement):
return False
return True
def preference_valid(complement):
preference = complement.selective_preference
if preference is None:
return False
generals = preference.generals
synsets = preference.synsets
relations = preference.relations
synset_relations = preference.synset_relations
if generals.count() + synsets.count() + relations.count() + synset_relations.count() > 0:
return True
return False
def examples_added(frame):
for lexical_unit in frame.lexical_units.all():
if LexicalUnitExamples.objects.filter(lexical_unit=lexical_unit).exists():
return True
return False
def duplicates_exists(frame, actual_frames):
frames_to_check = actual_frames.exclude(id=frame.id)
if get_matching_frame(frames_to_check, frame):
return True
return False
def schemas_reflex_agreed(lemma, frame):
agreed = True
complements = frame.complements.all()
lexical_units = frame.lexical_units.all()
for schema in lemma.frames.all():
schema_agreed = False
for lex_unit in lexical_units:
if schema_lex_unit_reflex_agree(lex_unit, schema, complements):
schema_agreed = True
break
if not schema_agreed:
agreed = False
break
return agreed
def schema_lex_unit_reflex_agree(lexical_unit, schema, complements):
if complements.filter(realizations__frame=schema).exists():
if (not reflex_with_self_mark_agreed(lexical_unit, schema) and
not (lexical_unit.is_reflexive() and not lexical_unit.is_new() and
reflex_with_phrase_types_agreed(lexical_unit, schema, complements))):
return False
return True
def reflex_with_self_mark_agreed(lexical_unit, schema):
schema_self_mark = schema.get_char_value('ZWROTNOŚĆ').value
if not lexical_unit.is_reflexive() == bool(schema_self_mark):
return False
return True
def reflex_with_phrase_types_agreed(lexical_unit, schema, complements):
max_alternations = complements.all().aggregate(Max('realizations__alternation'))['realizations__alternation__max']
for alternation in range(1, max_alternations+1):
if not reflex_with_alternation_phrase_types_agreed(complements, schema, alternation):
return False
return True
def reflex_with_alternation_phrase_types_agreed(complements, schema, alternation):
for compl in complements:
if compl.realizations.filter(argument__type__in=reflex_phrase_types(),
alternation=alternation,
frame=schema).exists():
return True
return False
def nonch_pinned(frame):
if frame.complements.filter(realizations__argument__text_rep='nonch'):
return True
return False
def multiplied_same_arg_in_schema(frame):
for compl in frame.complements.all():
for real in compl.realizations.all():
same_frame_realizations = compl.realizations.filter(frame=real.frame,
alternation=real.alternation)
if same_frame_realizations.exclude(position=real.position).exists():
return True
return False
def validate_schemas(lemma_id):
error_msg = ''
lemma = Lemma.objects.get(id=lemma_id, old=False)
if not all_schemas_used(lemma):
error_msg = u'Semantyka nie wykorzystuje wszystkich poprawnych schematów walencyjnych.'
return error_msg
def all_schemas_used(lemma):
frames = lemma.entry_obj.actual_frames()
schemas = lemma.frames
for schema in schemas.all():
if not schema_is_bad(lemma, schema) and not schema_used(schema, frames):
return False
return True
def schema_is_bad(lemma, schema):
schema_opinion = lemma.frame_opinions.get(frame=schema)
if schema_opinion.value.short == 'bad':
return True
return False
def schema_used(schema, frames):
for frame in frames:
if frame.complements.filter(realizations__frame=schema).exists():
return True
return False
def validate_lexical_units(lemma_id):
error_msg = ''
lemma = Lemma.objects.get(id=lemma_id, old=False)
lexical_units = lemma.entry_obj.lexical_units()
for lex_unit in lexical_units.all():
if not examples_reflex_agreed(lex_unit):
error_msg = u'Semantyka: Znaczenie %s ma podpięte przykłady o niezgodnej zwrotności.' % unicode(lex_unit)
return error_msg
def examples_reflex_agreed(lexical_unit):
lex_examples = LexicalUnitExamples.objects.filter(lexical_unit=lexical_unit)
for lex_example in lex_examples:
schema_reflex = lex_example.example.frame.get_char_value('ZWROTNOŚĆ').value
if (not (lexical_unit.is_reflexive() == bool(schema_reflex)) and
not (lexical_unit.is_reflexive() and not lexical_unit.is_new() and
lex_example.example.arguments.filter(arguments__type__in=reflex_phrase_types()).exists())):
return False
return True