polish_strings.py
20.7 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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
from django.utils.text import format_lazy
from django.utils.translation import gettext_lazy as _
from django.utils.translation import pgettext_lazy
from django.utils import translation
def POSITION_PROP():
return{
'subj' : _('podmiot'),
'obj' : _('dopełnienie dopuszczające stronę bierną'),
'head' : _('rzeczownikowy nadrzędnik składniowy frazy przymiotnikowej'),
'controller' : _('pozycja kontrolująca podmiot bezokolicznika lub jego odpowiednik (podnoszenie wykonawcy czynności)'),
'controllee' : _('pozycja podlegająca kontroli czynnościowej (dziedzicząca wykonawcę czynności)'),
'pred_controller' : _('pozycja kontrolująca pozycję predykatywną (posiadacz własności)'),
'pred_controllee' : _('pozycja predykatywna kontrolowana przez inną pozycję'),
}
# there’s an NP class in the importer
def NP_():
# Translators: fraza, rzeczownikowa
return (_('%(a1)s %(a2)s w {case}'), 'fraza', 'rzeczownikowa')
def NUMP():
# Translators: fraza, liczebnikowa
return (_('%(a1)s %(a2)s w {case}'), 'fraza', 'liczebnikowa')
def ADJP():
# Translators: fraza, przymiotnikowa
return (_('%(a1)s %(a2)s w {case}'), 'fraza', 'przymiotnikowa')
# TODO różne opisy?
def PPASP():
# Translators: fraza, imiesłowowa
return (_('%(a1)s %(a2)s w {case}'), 'fraza', 'imiesłowowa')
def PACTP():
# Translators: fraza, imiesłowowa
return (_('%(a1)s %(a2)s w {case}'), 'fraza', 'imiesłowowa')
def CASE_FOR_NP():
return {
'nom' : _('mianowniku'),
'gen' : _('dopełniaczu'),
'dat' : _('celowniku'),
'acc' : _('bierniku'),
'inst' : _('narzędniku'),
'str_subj' : _('przypadku strukturalnym (mianownik)'),
'str' : _('przypadku strukturalnym (biernik albo dopełniacz w zależności od negacji)'),
'pred' : _('przypadku predykatywnym (narzędnik bądź przypadek narzucany przez element kontrolujący na pozycji predykatywnej)'),
'agr' : _('przypadku uzgadniającym (z nadrzędnikiem rzeczownikowym w wypadku apozycji lub podrzędnikiem przymiotnikowym)'),
'part' : _('przypadku służącym do opisu rozchwiania pomiędzy biernikiem a dopełniaczem charakterystycznego dla rzeczowników partytywnych (podzielnych, np. <i>chleb</i>) oraz niepoliczalnych (np. <i>woda</i>). Np. <i>zjeść chleb/chleba</i>, <i>nalać wodę/wody</i>'),
}
def CASE_FOR_ADJP():
ret = CASE_FOR_NP()
ret['agr'] = _('przypadku uzgadniającym z nadrzędnikiem rzeczownikowym')
return ret
def PREPNP():
# Translators: fraza, rzeczownikowa
return (_('%(a1)s przyimkowo-%(a2)s z przyimkiem <i>{prep}</i> wymagającym {case}'), 'fraza', 'rzeczownikowa')
def PREPGERP():
# Translators: fraza, odsłownikowa
return (_('%(a1)s przyimkowo-%(a2)s z przyimkiem <i>{prep}</i> wymagającym {case}'), 'fraza', 'odsłownikowa')
def PREPNUMP():
# Translators: fraza, liczebnikowa
return (_('%(a1)s przyimkowo-%(a2)s z przyimkiem <i>{prep}</i> wymagającym {case}'), 'fraza', 'liczebnikowa')
def PREPADJP():
# Translators: fraza, przymiotnikowa
return (_('%(a1)s przyimkowo-%(a2)s z przyimkiem <i>{prep}</i> wymagającym {case}'), 'fraza', 'przymiotnikowa')
def PREPPPASP():
# Translators: fraza, imiesłowowa
return (_('%(a1)s przyimkowo-%(a2)s z przyimkiem <i>{prep}</i> wymagającym {case}'), 'fraza', 'imiesłowowa')
# TODO dowolna przyimkowa czy przyim-rzecz?
def COMPREPNP():
# Translators: fraza, rzeczownikowa
return (_('%(a1)s przyimkowo-%(a2)s z przyimkiem złożonym <i>{prep}</i>'), 'fraza', 'rzeczownikowa')
def CASE_FOR_PREPNP():
return {
'nom' : _('mianownika'),
'gen' : _('dopełniacza'),
'dat' : _('celownika'),
'acc' : _('biernika'),
'inst' : _('narzędnika'),
'loc' : _('miejscownika'),
# TODO przeredagowałam: Przypadek strukturalny występuje tez z przyimkami jak (prepnp(jak, str)) oraz jako (prepnp(jako,str)) będącymi rodzajem konstrukcji porównawczych. Frazy takie występują zawsze na pozycji predykatywnej podlegającej kontroli i uzgadniają przypadek strukturalny z frazą kontrolującą.
'str' : _('przypadka strukturalnego występującego z przyimkami <i>jak</i> oraz <i>jako</i> będącymi rodzajem konstrukcji porównawczych (frazy takie występują zawsze na pozycji predykatywnej podlegającej kontroli i uzgadniają przypadek strukturalny z frazą kontrolującą)'),
# TODO nie było w dokumentacji, występuje np. w prepadjp(po,postp)
'postp' : _('celownika poprzyimkowego'),
}
def INFP():
# Translators: fraza, bezokolicznikowa
return (_('{aspect} %(a1)s %(a2)s'), 'fraza', 'bezokolicznikowa')
def ASPECT():
return {
'imperf' : (_('%(a1)s'), 'niedokonana'),
'perf' : (_('%(a1)s'), 'dokonana'),
'_' : (_('%(a1)s'), 'dowolna'),
}
# there’s a CP class in the importer
# TODO variants for realisations/lexes (no “odpowiedni zaimek...”)
def CP_():
# Translators: fraza, zdaniowa
return (_('%(a1)s %(a2)s {typ}'), 'fraza', 'zdaniowa')
def CP_TYPE():
return {
# Translators: wprowadzana
'gdy' : (_('%(a1)s przez spójnik podrzędny <i>gdy</i> oraz <i>gdyby</i> w trybie przypuszczającym'), 'wprowadzana'),
# Translators: wprowadzana
'żeby2' : (_('%(a1)s przez spójnik podrzędny <i>że</i> oraz dodatkowo <i>żeby</i> w konstrukcjach zanegowanych'), 'wprowadzana'),
# Translators: zależna, wprowadzana
'int' : (_('pytajno-%(a1)s %(a2)s przez odpowiedni zaimek pytajny'), 'zależna', 'wprowadzana'),
# Translators: względna, wprowadzana
'rel' : (_('%(a1)s %(a2)s przez odpowiedni zaimek względny'), 'względna', 'wprowadzana'),
# Translators: zależna, wprowadzana
'int_r' : (_('pytajno-%(a1)s %(a2)s przez <i>{conj}</i>'), 'zależna', 'wprowadzana'),
# Translators: względna, wprowadzana
'rel_r' : (_('%(a1)s %(a2)s przez <i>{conj}</i>'), 'względna', 'wprowadzana'),
}
# TODO(?) this is a catch-all, should we check that the conj is valid?
def CP_CONJ():
# Translators: wprowadzana
return (_('%(a1)s przez spójnik podrzędny <i>{conj}</i>'), 'wprowadzana')
# there’s an NCP class in the importer
def NCP_():
# Translators: fraza, zdaniowa
return (_('%(a1)s %(a2)s {typ}'), 'fraza', 'zdaniowa')
TO = {
'nom' : 'to',
'gen' : 'tego',
'dat' : 'temu',
'acc' : 'to',
'inst' : 'tym',
'loc' : 'tym',
'str' : 'to',
'pred' : 'tym',
'agr' : 'to',
'part' : 'tego',
}
def NCP_TYPE():
return {
# Translators: wprowadzana
'gdy' : (_('%(a1)s przez <i>{to}, gdy</i> bądź <i>{to}, gdyby</i> w trybie przypuszczającym'), 'wprowadzana'),
# Translators: wprowadzana
'żeby2' : (_('%(a1)s przez <i>{to}, że</i> bądź dodatkowo <i>{to}, żeby</i> w konstrukcjach zanegowanych'), 'wprowadzana'),
# Translators: zależna, wprowadzana
'int' : (_('pytajno-%(a1)s %(a2)s przez <i>{to}, co (czy, ile, kto)</i> lub dowolny inny zaimek pytajny'), 'zależna', 'wprowadzana'),
# Translators: względna, wprowadzana
'rel' : (_('%(a1)s %(a2)s przez <i>{to}, co (gdzie, kto)</i> lub dowolny inny zaimek względny'), 'względna', 'wprowadzana'),
# Translators: zależna, wprowadzana
'int_r' : (_('pytajno-%(a1)s %(a2)s przez <i>{to}, {conj}</i>'), 'zależna', 'wprowadzana'),
# Translators: względna, wprowadzana
'rel_r' : (_('%(a1)s %(a2)s przez <i>{to}, {conj}</i>'), 'względna', 'wprowadzana'),
}
def NCP_CONJ():
# Translators: wprowadzana
return (_('%(a1)s przez <i>{to}, {conj}</i>'), 'wprowadzana')
def PREPNCP_TYPE():
return {
# Translators: wprowadzana
'gdy' : (_('%(a1)s przez <i>{prep} {to}, gdy</i> bądź <i>{prep} {to}, gdyby</i> w trybie przypuszczającym'), 'wprowadzana'),
# Translators: wprowadzana
'żeby2' : (_('%(a1)s przez <i>{prep} {to}, że</i> bądź dodatkowo <i>{prep} {to}, żeby</i> w konstrukcjach zanegowanych'), 'wprowadzana'),
# Translators: zależna, wprowadzana
'int' : (_('pytajno-%(a1)s %(a2)s przez <i>{prep} {to}, co (czy, ile, kto)</i> lub dowolny inny zaimek pytajny'), 'zależna', 'wprowadzana'),
# Translators: względna, wprowadzana
'rel' : (_('%(a1)s %(a2)s przez <i>{prep} {to}, co (gdzie, kto)</i> lub dowolny inny zaimek względny'), 'względna', 'wprowadzana'),
# Translators: zależna, wprowadzana
'int_r' : (_('pytajno-%(a1)s %(a2)s przez <i>{prep} {to}, {conj}</i>'), 'zależna', 'wprowadzana'),
# Translators: względna, wprowadzana
'rel_r' : (_('%(a1)s %(a2)s przez <i>{prep} {to}, {conj}</i>'), 'względna', 'wprowadzana'),
}
def PREPNCP_CONJ():
# Translators: wprowadzana
return (_('%(a1)s przez <i>{prep} {to}, {conj}</i>'), 'wprowadzana')
#### advp:
# fraza_1 przysłówkowa_2 lokatywna_3 (miejsce)
# locative_3 adverbial_2 phrase_1 (place)
def ADVP():
s = pgettext_lazy('fraza przysłówkowa lokatywna/ablatywna/...', '%(a1)s %(a2)s %(a3)s')
return {
'locat' : (format_lazy('{} {}', s, _('(miejsce)')), 'fraza', 'przysłówkowa', 'lokatywna'),
'abl' : (format_lazy('{} {}', s, _('(miejsce początkowe)')), 'fraza', 'przysłówkowa', 'ablatywna'),
'adl' : (format_lazy('{} {}', s, _('(miejsce końcowe)')), 'fraza', 'przysłówkowa', 'adlatywna'),
'perl' : (format_lazy('{} {}', s, _('(trasa)')), 'fraza', 'przysłówkowa', 'perlatywna'),
'temp' : (format_lazy('{} {}', s, _('(czasu)')), 'fraza', 'przysłówkowa', 'temporalna'),
'dur' : (format_lazy('{} {}', s, _('(trwania)')), 'fraza', 'przysłówkowa', 'duratywna'),
'mod' : (pgettext_lazy('fraza przysłówkowa', '%(a1)s %(a2)s sposobu'), 'fraza', 'przysłówkowa'),
'caus' : (format_lazy('{} {}', s, _('(przyczyny)')), 'fraza', 'przysłówkowa', 'kauzatywna'),
'dest' : (format_lazy('{} {}', s, _('(celu)')), 'fraza', 'przysłówkowa', 'destynacyjna'),
'instr' : (format_lazy('{} {}', s, _('(narzędzie)')), 'fraza', 'przysłówkowa', 'instrumentalna'),
}
#### xp without realisations:
# dowolna_1 fraza_2 lokatywna_3 (miejsce)
# any_1 locative_3 phrase_2 (place)
#### xp with realisations:
# fraza_1 lokatywna_2 (miejsce)
# locative_2 phrase_1 (place)
#def XP_SEM():
def XP_(reals):
if reals:
# Translators: fraza, lokatywna/ablatywna/...
s = _('%(a1)s %(a2)s')
return {
'locat' : (format_lazy('{} {}', s, _('(miejsce)')), 'fraza', 'lokatywna'),
'abl' : (format_lazy('{} {}', s, _('(miejsce początkowe)')), 'fraza', 'ablatywna'),
'adl' : (format_lazy('{} {}', s, _('(miejsce końcowe)')), 'fraza', 'adlatywna'),
'perl' : (format_lazy('{} {}', s, _('(trasa)')), 'fraza', 'perlatywna'),
'temp' : (format_lazy('{} {}', s, _('(czasu)')), 'fraza', 'temporalna'),
'dur' : (format_lazy('{} {}', s, _('(trwania)')), 'fraza', 'duratywna'),
# Translators: fraza
'mod' : (_('%(a1)s sposobu'), 'fraza'),
'caus' : (format_lazy('{} {}', s, _('(przyczyny)')), 'fraza', 'kauzatywna'),
'dest' : (format_lazy('{} {}', s, _('(celu)')), 'fraza', 'destynacyjna'),
'instr' : (format_lazy('{} {}', s, _('(narzędzie)')), 'fraza', 'instrumentalna'),
}
else:
s = pgettext_lazy('dowolna fraza lokatywna/ablatywna/...', '%(a1)s %(a2)s %(a3)s')
return {
'locat' : (format_lazy('{} {}', s, _('(miejsce)')), 'dowolna', 'fraza', 'lokatywna'),
'abl' : (format_lazy('{} {}', s, _('(miejsce początkowe)')), 'dowolna', 'fraza', 'ablatywna'),
'adl' : (format_lazy('{} {}', s, _('(miejsce końcowe)')), 'dowolna', 'fraza', 'adlatywna'),
'perl' : (format_lazy('{} {}', s, _('(trasa)')), 'dowolna', 'fraza', 'perlatywna'),
'temp' : (format_lazy('{} {}', s, _('(czasu)')), 'dowolna', 'fraza', 'temporalna'),
'dur' : (format_lazy('{} {}', s, _('(trwania)')), 'dowolna', 'fraza', 'duratywna'),
'mod' : (pgettext_lazy('dowolna fraza', '%(a1)s %(a2)s sposobu'), 'dowolna', 'fraza'),
'caus' : (format_lazy('{} {}', s, _('(przyczyny)')), 'dowolna', 'fraza', 'kauzatywna'),
'dest' : (format_lazy('{} {}', s, _('(celu)')), 'dowolna', 'fraza', 'destynacyjna'),
'instr' : (format_lazy('{} {}', s, _('(narzędzie)')), 'dowolna', 'fraza', 'instrumentalna'),
}
def ADVP_PRON():
# Translators: zaimki, przysłówkowe
return (_('wyłącznie %(a1)s %(a2)s <i>jak</i>, <i>tak</i>'), 'zaimki', 'przysłówkowe')
def ADVP_MISC():
# Translators: fraza, przysłówkowa, fraza, konstrukcje, przysłówkowe
return (_('%(a1)s %(a2)s (%(a3)s z centrum przysłówkowym oraz %(a4)s przyimkowo-%(a5)s typu <i>na pewno</i>, <i>bez mała</i>)'), 'fraza', 'przysłówkowa', 'fraza', 'konstrukcje', 'przysłówkowe')
def COMPAR():
# Translators: fraza, porównawcza, wprowadzana
return (_('%(a1)s %(a2)s %(a3)s przez <i>{prep}</i>'), 'fraza', 'porównawcza', 'wprowadzana')
def NONCH():
# Translators: fraza, niechromatyczna, specyficzna, fraza, realizowana
return (_('%(a1)s %(a2)s, czyli %(a3)s %(a4)s rzeczownikowa w przypadku strukturalnym, %(a5)s wyłącznie przez zaimki <i>co</i>, <i>coś</i>, <i>nic</i>, <i>to</i> oraz nieokreślone frazy liczebnikowe (<i>dużo</i>, <i>niewiele</i> itp.) bez podrzędnika rzeczownikowego'), 'fraza', 'niechromatyczna', 'specyficzna', 'fraza', 'realizowana')
# there’s an OR class in the importer
def OR_():
# Translators: mowa, niezależna
return (_('%(a1)s %(a2)s'), 'mowa', 'niezależna')
def REFL():
# Translators: partykuła, realizująca
return (_('%(a1)s <i>się</i> %(a2)s użycie zwrotne czasownika (<i>sam siebie</i>)'), 'partykuła', 'realizująca')
def RECIP():
# Translators: partykuła, realizująca
return (_('%(a1)s <i>się</i> %(a2)s użycie wzajemnościowe czasownika (<i>siebie nawzajem</i>)'), 'partykuła', 'realizująca')
# there’s an E class in the importer
def E_():
# Translators: subject
return (_('%(a1)s czasownika wymagającego bezokolicznika, którego własności są tożsame z narzucanymi przez czasownik w bezokoliczniku, w tym brak podmiotu'), 'podmiot')
def POSSP():
# Translators: fraza, posesywna, odpowiadająca
return (_('%(a1)s %(a2)s %(a3)s na pytanie <i>czyj?</i>, np. <i>mój</i>, <i>pański</i>, <i>Anny</i>'), 'fraza', 'posesywna', 'odpowiadająca')
# TODO przeredagowałam: fraza przyimkowo-nominalna z przyimkiem po stosowana w konstrukcjach dystrybutywnych. Charakteryzuje się tym, że typowo przyimek po wymaga miejscownika (prepnp(po,loc) – dać każdemu po jabłku), jednak w wypadku fraz liczebnikowych występuje tam biernik (prepnp(po,acc) – dać każdemu po dwa jabłka).
def DISTRP():
# Translators: fraza, rzeczownikowa, stosowana
return (_('%(a1)s przyimkowo-%(a2)s z przyimkiem <i>po</i> %(a3)s w konstrukcjach dystrybutywnych; typowo przyimek <i>po</i> wymaga miejscownika (<i>dać każdemu po jabłku</i>), jednak w wypadku fraz liczebnikowych występuje biernik (<i>dać każdemu po dwa jabłka</i>)'), 'fraza', 'rzeczownikowa', 'stosowana')
def QUB():
return (_('%(a1)s'), 'partykuła')
XP_SEM_PHRASEO = {
'locat' : '‹gdzieś›',
'abl' : '‹skądś›',
'adl' : '‹dokądś›',
'perl' : '‹którędyś›',
'temp' : '‹kiedyś›',
'dur' : '‹przez jakiś czas›',
'mod' : '‹w jakiś sposób›',
'caus' : '‹z jakiegoś powodu›',
'dest' : '‹w jakimś celu›',
'instr' : '‹za pomocą czegoś›',
# TODO for advp
'misc' : 'TODO',
}
def INFLECTED():
return {
'ablatywna' : { 'nom' : _('ablatywna'), 'gen' : _('ablatywnej'), 'inst' : _('ablatywną') },
'adlatywna' : { 'nom' : _('adlatywna'), 'gen' : _('adlatywnej'), 'inst' : _('adlatywną') },
'bezokolicznikowa' : { 'nom' : _('bezokolicznikowa'), 'gen' : _('bezokolicznikowej'), 'inst' : _('bezokolicznikową') },
'destynacyjna' : { 'nom' : _('destynacyjna'), 'gen' : _('destynacyjnej'), 'inst' : _('destynacyjną') },
'dokonana' : { 'nom' : _('dokonana'), 'gen' : _('dokonanej'), 'inst' : _('dokonaną') },
'dowolna' : { 'nom' : _('dowolna'), 'gen' : _('dowolnej'), 'inst' : _('dowolną') },
'duratywna' : { 'nom' : _('duratywna'), 'gen' : _('duratywnej'), 'inst' : _('duratywną') },
'fraza' : { 'nom' : _('fraza'), 'gen' : _('frazy'), 'inst' : _('frazą') },
'instrumentalna' : { 'nom' : _('instrumentalna'), 'gen' : _('instrumentalnej'), 'inst' : _('instrumentalną') },
'imiesłowowa' : { 'nom' : _('imiesłowowa'), 'gen' : _('imiesłowowej'), 'inst' : _('imiesłowową') },
'kauzatywna' : { 'nom' : _('kauzatywna'), 'gen' : _('kauzatywnej'), 'inst' : _('kauzatywną') },
'konstrukcje' : { 'nom' : _('konstrukcje'), 'gen' : _('konstrukcyj'), 'inst' : _('konstrukcjami') },
'liczebnikowa' : { 'nom' : _('liczebnikowa'), 'gen' : _('liczebnikowej'), 'inst' : _('liczebnikową') },
'lokatywna' : { 'nom' : _('lokatywna'), 'gen' : _('lokatywnej'), 'inst' : _('lokatywną') },
'mowa' : { 'nom' : _('mowa'), 'gen' : _('mowy'), 'inst' : _('mową') },
'niechromatyczna' : { 'nom' : _('niechromatyczna'), 'gen' : _('niechromatycznej'), 'inst' : _('niechromatyczną') },
'niedokonana' : { 'nom' : _('niedokonana'), 'gen' : _('niedokonanej'), 'inst' : _('niedokonaną') },
'niezależna' : { 'nom' : _('niezależna'), 'gen' : _('niezależnej'), 'inst' : _('niezależną') },
'odpowiadająca' : { 'nom' : _('odpowiadająca'), 'gen' : _('odpowiadającej'), 'inst' : _('odpowiadającą') },
'odsłownikowa' : { 'nom' : _('odsłownikowa'), 'gen' : _('odsłownikowej'), 'inst' : _('odsłownikową') },
'partykuła' : { 'nom' : _('partykuła'), 'gen' : _('partykuły'), 'inst' : _('partykułą') },
'perlatywna' : { 'nom' : _('perlatywna'), 'gen' : _('perlatywnej'), 'inst' : _('perlatywną') },
'podmiot' : { 'nom' : _('podmiot'), 'gen' : _('podmiotu'), 'inst' : _('podmiotem') },
'posesywna' : { 'nom' : _('posesywna'), 'gen' : _('posesywnej'), 'inst' : _('posesywną') },
'porównawcza' : { 'nom' : _('porównawcza'), 'gen' : _('porównawczej'), 'inst' : _('porównawczą') },
'przymiotnikowa' : { 'nom' : _('przymiotnikowa'), 'gen' : _('przymiotnikowej'), 'inst' : _('przymiotnikową') },
'przysłówkowa' : { 'nom' : _('przysłówkowa'), 'gen' : _('przysłówkowej'), 'inst' : _('przysłówkową') },
'przysłówkowe' : { 'nom' : _('przysłówkowe'), 'gen' : _('przysłówkowych'), 'inst' : _('przysłówkowymi') },
'realizowana' : { 'nom' : _('realizowana'), 'gen' : _('realizowanej'), 'inst' : _('realizowaną') },
'realizująca' : { 'nom' : _('realizująca'), 'gen' : _('realizującej'), 'inst' : _('realizującą') },
'rzeczownikowa' : { 'nom' : _('rzeczownikowa'), 'gen' : _('rzeczownikowej'), 'inst' : _('rzeczownikową') },
'specyficzna' : { 'nom' : _('specyficzna'), 'gen' : _('specyficznej'), 'inst' : _('specyficzną') },
'stosowana' : { 'nom' : _('stosowana'), 'gen' : _('stosowanej'), 'inst' : _('stosowaną') },
'temporalna' : { 'nom' : _('temporalna'), 'gen' : _('temporalnej'), 'inst' : _('temporalną') },
'wprowadzana' : { 'nom' : _('wprowadzana'), 'gen' : _('wprowadzanej'), 'inst' : _('wprowadzaną') },
'względna' : { 'nom' : _('względna'), 'gen' : _('względnej'), 'inst' : _('względną') },
'zaimki' : { 'nom' : _('zaimki'), 'gen' : _('zaimków'), 'inst' : _('zaimkami') },
'zależna' : { 'nom' : _('zależna'), 'gen' : _('zależnej'), 'inst' : _('zależną') },
'zdaniowa' : { 'nom' : _('zdaniowa'), 'gen' : _('zdaniowej'), 'inst' : _('zdaniową') },
#'' : { 'nom' : _(''), 'gen' : _(''), 'inst' : _('') },
}
def make_inflected_string(pattern, case):
template, words = pattern[0], pattern[1:]
inflected = INFLECTED()
kwargs = { 'a{}'.format(i + 1) : inflected[w][case] for i, w in enumerate(words) }
return template % kwargs