validation.py
6.32 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
# -*- coding: utf-8 -*-
from dictionary.models import Lemma
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(frame, actual_frames)
if error_msg:
break
return error_msg
def frame_valid(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(frame):
error_msg = u'Semantyka: Rama semantyczna %d ma dopięte schematy o niezgodnej ze znaczeniami 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(frame):
complements = frame.complements.all()
lexical_units = frame.lexical_units.all()
for compl in complements:
for real in compl.realizations.all():
schema_reflex = real.frame.get_char_value('ZWROTNOŚĆ').value
if (not reflex_in_lexical_units(lexical_units, schema_reflex)):
return False
return True
#def refl_like_phrase_type_pinned(compl, real):
# same_frame_realizations = compl.realizations.filter(frame=real.frame,
# alternation=real.alternation)
def reflex_in_lexical_units(lexical_units, reflex):
for lex_unit in lexical_units:
if lex_unit.is_reflexive() == bool(reflex):
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 ze schematów 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)):
return False
return True