specialised_fields.py
5.18 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
from django import forms
from django.db.models import Q
from django.utils.translation import gettext_lazy as _
import crispy_forms.bootstrap as bootstrap
from syntax.models_phrase import PhraseTypeModel
from semantics.models import (
Frame, SemanticRole, RoleAttribute,
PredefinedSelectionalPreference,
Synset,
RelationalSelectionalPreference,
SelectionalPreferenceRelation,
)
from .generic_fields import (
RadiosLayoutField,
SingleRegexFilter,
ModelChoiceFilter,
ModelMultipleChoiceFilter,
)
from .query_managers import (
QueryManager,
DUMMY_LOOKUP,
)
from entries.polish_strings import PHRASE_TYPE
class PhraseTypeFilter(ModelChoiceFilter):
def __init__(self, queryset=None, lex=False, **kwargs):
if queryset is None:
if lex:
queryset = PhraseTypeModel.objects.filter(main_phrase_types__lex_phrases__isnull=False).distinct()
else:
queryset = PhraseTypeModel.objects.filter(main_phrase_types__positions__isnull=False).distinct()
super().__init__(
label=(_('Typ frazy zleksykalizowanej') if lex else _('Typ frazy')),
queryset=queryset,
key='name',
# this field is not used for filtering, only for choosing subform type
lookup=DUMMY_LOOKUP,
# we will want to identify the selected phrase type by name later
to_field_name='name',
empty_label=_('wybierz'),
**kwargs,
)
def label_from_instance(self, obj):
pt = obj.name
return '{} ({})'.format(pt, PHRASE_TYPE().get(pt, '...'))
# TODO implementation without internal QueryManager subclass?
# TODO possibly refactor and check
class PhraseoFilter(forms.ChoiceField, RadiosLayoutField):
class PhraseoQueryManager(QueryManager):
def __init__(self):
super().__init__(None, None)
# Assumes this filter is used on either Entry or Schema and uses the
# fact that both have the same related name for Subentry
def _make_queries(self, _, value, op):
if value == '1':
return [Q(subentries__schemata__phraseologic=True)]
if value == '0':
return [~Q(subentries__schemata__phraseologic=True)]
return []
def __init__(self):
super().__init__(
label=_('Frazeologia'),
choices=(('2', _('dowolnie')), ('1', _('zawiera')), ('0', _('nie zawiera'))),
initial='2',
required=False,
)
self.query_manager = PhraseoFilter.PhraseoQueryManager()
# crispy_forms/bootstap.py
class RoleCheckboxes(bootstrap.Field):
template = 'role_checkboxselectmultiple.html'
class RoleFilter(ModelMultipleChoiceFilter):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# choice: (value, (label, tooltip_text))
self.choices_index = { choice[1][0] : choice for choice in self.choices }
def layout(self, x, **kwargs):
return RoleCheckboxes(x, **kwargs)
def _choices_group(self, *choice_names):
return [self.choices_index[x] for x in choice_names]
def header(self):
raise NotImplementedError
def rows(self):
raise NotImplementedError
class RoleNameFilter(RoleFilter):
def __init__(self, label, lookup, **kwargs):
super().__init__(
label=label,
#queryset=SemanticRole.objects.filter(argumentrole__argument__isnull=False).distinct(),
queryset=SemanticRole.objects.all(),
key='role',
lookup=lookup,
**kwargs,
)
def header(self):
return ('', _('inicjujące'), _('towarzyszące'), _('zamykające'))
def rows(self):
return (
{
'name': _('podstawowe'),
'cols': (
self._choices_group('Initiator', 'Stimulus'),
self._choices_group('Theme', 'Experiencer', 'Factor', 'Instrument'),
self._choices_group('Recipient', 'Result'),
)
},
{
'name': _('uzupełniające'),
'cols': (
self._choices_group('Condition'),
self._choices_group('Attribute', 'Manner', 'Measure', 'Location', 'Path', 'Time', 'Duration'),
self._choices_group('Purpose'),
)
},
)
class RoleAttributeFilter(RoleFilter):
def __init__(self, label, lookup, **kwargs):
super().__init__(
label=label,
#queryset=RoleAttribute.objects.filter(argumentrole__argument__isnull=False).distinct(),
queryset=RoleAttribute.objects.all(),
key='attribute',
lookup=lookup,
**kwargs,
)
def header(self):
return None
def rows(self):
return (
{
'name': '',
'cols': (
self._choices_group('Source'),
self._choices_group('Foreground', 'Background'),
self._choices_group('Goal'),
)
},
)